@theseam/ui-common 2.0.1-beta.114 → 2.0.1-beta.119

package/fesm2022/theseam-ui-common-google-maps.mjs

@@ -510,6 +510,27 @@ function mergeStyleOptions(target, source) {
     }
     return target;
 }
+/**
+ * Whether the feature declines to opt OUT of `option`.
+ *
+ * Resolved per key, not per object: a selected feature consults
+ * `styleOptionsSelected` first and falls back to `styleOptions` only for a key
+ * `styleOptionsSelected` does not itself mention. Otherwise a feature
+ * declaring `styleOptionsSelected` for an unrelated reason, such as a
+ * different selected fill colour, would silently lose an unrelated
+ * `editable: false` from `styleOptions` the moment it is selected.
+ *
+ * Only an explicit `false` opts out. Shared by `computeFeatureStyle` and the
+ * delete gate in `GoogleMapsService`, so the lock a consumer declares means
+ * the same thing to both.
+ */
+function featureAllows(feature, option) {
+    const selectedDeclared = isFeatureSelected(feature)
+        ? getSelectedStyleOptionsDefinedByFeature(feature)
+        : undefined;
+    const baseDeclared = getStyleOptionsDefinedByFeature(feature);
+    return (selectedDeclared?.[option] ?? baseDeclared?.[option]) !== false;
+}
 /**
  * The style for a feature, in a fixed precedence order:
  *
@@ -537,37 +558,29 @@ function mergeStyleOptions(target, source) {
  * feature that opts out of one opts out of the other. This implication runs
  * only one way — `draggable: false` alone does not imply `editable: false`, so
  * a feature may still opt out of dragging while remaining reshapeable via its
- * vertex handles. Resolved through the same per-key `wants()` lookup as
- * `editable` itself, so a feature that locks `editable: false` in
- * `styleOptions` cannot be dragged even if `styleOptionsSelected` declares
- * `draggable` for an unrelated reason (or not at all).
+ * vertex handles. Resolved through `featureAllows`, which the delete gate
+ * shares, so a feature that locks `editable: false` in `styleOptions` cannot
+ * be dragged even if `styleOptionsSelected` declares `draggable` for an
+ * unrelated reason (or not at all).
  */
 function computeFeatureStyle(feature, context) {
     const selected = isFeatureSelected(feature);
-    const baseDeclared = getStyleOptionsDefinedByFeature(feature);
-    const selectedDeclared = selected
-        ? getSelectedStyleOptionsDefinedByFeature(feature)
-        : undefined;
     const options = FEATURE_STYLE_OPTIONS_DEFAULT();
     mergeStyleOptions(options, getStyleOptionsDefinedByFeature(feature));
     if (selected) {
         mergeStyleOptions(options, FEATURE_STYLE_OPTIONS_SELECTED());
         mergeStyleOptions(options, getSelectedStyleOptionsDefinedByFeature(feature));
     }
-    // Resolved per key, not per object. A feature that opts out in
-    // `styleOptions` must stay opted out even when it also declares a
-    // `styleOptionsSelected` for unrelated reasons such as colour — otherwise
-    // the clamp stops being one-directional and a retired field becomes
-    // editable the moment it is selected.
-    const wants = (option) => (selectedDeclared?.[option] ?? baseDeclared?.[option]) !== false;
     const editingArmed = context.editingEnabled && context.geometryEditingArmed && selected;
-    const wantsEditable = wants('editable');
+    const wantsEditable = featureAllows(feature, 'editable');
     options.editable = wantsEditable && editingArmed;
     // editable: false implies draggable: false (see the doc comment above) —
-    // the reverse does not hold, so wants('draggable') is still consulted on
-    // its own for a feature that opts out of dragging alone.
-    options.draggable = wants('draggable') && wantsEditable && editingArmed;
-    options.clickable = wants('clickable') && context.clicksAllowed;
+    // the reverse does not hold, so 'draggable' is still resolved on its own
+    // for a feature that opts out of dragging alone.
+    options.draggable =
+        featureAllows(feature, 'draggable') && wantsEditable && editingArmed;
+    options.clickable =
+        featureAllows(feature, 'clickable') && context.clicksAllowed;
     return options;
 }
 /**
@@ -1091,7 +1104,7 @@ class GoogleMapsService {
      * delay-free discriminator: a stale click's timestamp should predate the
      * moment the draw finished. It does not hold up empirically. Driving real
      * mouse draws against the live Storybook and logging both the map `click`
-     * listener and `stopDrawing()` (see .superpowers/closing-click-report.md)
+     * listener and `stopDrawing()` (see docs/superpowers/reports/closing-click-report.md)
      * caught the echo repeatedly, and every single time its `domEvent.timeStamp`
      * was a few milliseconds AFTER `stopDrawing()`'s own timestamp, not before
      * — indistinguishable from a genuinely fresh click by timestamp alone.
@@ -1117,6 +1130,21 @@ class GoogleMapsService {
     _labelProperty;
     _labelsOverlay;
     _warnedAboutLabelDisagreement = false;
+    _canDelete;
+    _deleteBlockedSubject = new Subject();
+    /**
+     * A delete that was attempted and refused. Fires only from the three delete
+     * commands, never from their `canDelete*` queries — rendering a menu is not
+     * an attempt.
+     */
+    deleteBlocked$ = this._deleteBlockedSubject.asObservable();
+    /**
+     * A file reached one of the import paths and could not be read. Plain
+     * `Subject`, not `BehaviorSubject`: a consumer subscribing later should not
+     * be handed a failure from before it was listening.
+     */
+    _fileImportErrorSubject = new Subject();
+    fileImportError$ = this._fileImportErrorSubject.asObservable();
     _selectionSubject = new BehaviorSubject(null);
     /**
      * `distinctUntilChanged` collapses repeated `null`s. Several paths clear the
@@ -1171,6 +1199,8 @@ class GoogleMapsService {
         this._contextMenuTargetSubject.complete();
         this._editModeSubject.complete();
         this._interactionModeSubject.complete();
+        this._deleteBlockedSubject.complete();
+        this._fileImportErrorSubject.complete();
         this._groups = undefined;
         this._labelsOverlay?.destroy();
         this._labelsOverlay = undefined;
@@ -1226,7 +1256,7 @@ class GoogleMapsService {
     /**
      * Iterates the map's features and removes any that are selected.
      */
-    deleteSelection() {
+    _removeSelection() {
         this._assertInitialized();
         const mapData = this.googleMap.data;
         mapData.forEach((f) => {
@@ -1236,13 +1266,201 @@ class GoogleMapsService {
         });
         // Every deleted feature was selected, so nothing should still read as
         // selected afterward. Re-sync `selection$` and `_focusedFeature` the same
-        // way `deleteFocusedFeature()` and `setData()` already do, rather than
+        // way `_removeFocusedFeature()` and `setData()` already do, rather than
         // leaving them pointing at a group that no longer exists. In 'legacy'
         // mode nothing consumes selection$ today, and no remaining feature's raw
         // selected flag changes here (they were already false), so this is inert
         // there.
         this.clearSelection();
     }
+    /**
+     * The consumer's veto. Consulted for every delete on every path, and for
+     * whether to offer a delete at all.
+     */
+    setCanDelete(predicate) {
+        this._canDelete = predicate ?? undefined;
+    }
+    /**
+     * Pair a set of features to remove with the target to consult `canDelete`
+     * with. `null` when there is nothing to delete — distinct from a refusal,
+     * and the reason no honest target exists to report.
+     *
+     * Builds `target.feature` itself rather than delegating the decision to
+     * `_targetFor`. There, `feature: null` means only "no particular feature";
+     * here it is a promise that the whole group is about to cease to exist.
+     * Conflating the two is what let a delete of ONE polygon be consulted as a
+     * group delete — see `ResolvedDeletion.unnamable`.
+     */
+    _deletionOf(key, removing) {
+        if (key === null || removing.length === 0) {
+            return null;
+        }
+        const resolved = this._registry.groupWithSources(key);
+        if (!resolved) {
+            return null;
+        }
+        // The empty-group invariant: a delete that leaves the group with no
+        // features at all is a group delete, whichever path asked for it — so
+        // `feature: null` always means "this group is about to cease to exist"
+        // and a consumer never has to count features itself. Compared against
+        // `featuresIn`, not `resolved.sources`, because a feature with
+        // unsupported geometry is missing from `sources` but still occupies the
+        // group.
+        const all = this._registry.featuresIn(key);
+        const emptiesGroup = all.every((f) => removing.indexOf(f) !== -1);
+        if (emptiesGroup) {
+            // `feature: null` is honest here whatever `removing` holds: the group
+            // really is going, unsupported-geometry members included. This case is
+            // never at risk, so it is never `unnamable`.
+            return {
+                removing,
+                target: { group: resolved.group, feature: null },
+                unnamable: false,
+            };
+        }
+        // The group survives, so the target must name the polygon being removed.
+        const index = resolved.sources.indexOf(removing[0]);
+        if (index === -1) {
+            // The feature being removed is absent from `sources`: its geometry is
+            // neither Polygon nor MultiPolygon, so `groupWithSources` dropped it and
+            // it has no emitted GeoJSON counterpart. It has never appeared in any
+            // `group.features` the consumer has seen, so NO value of
+            // `target.feature` describes it — which is exactly why this deletion is
+            // `unnamable` and `_mayDeleteResolved()` refuses it outright whenever a
+            // predicate is set.
+            //
+            // `feature: null` is the least dishonest option available. It overstates
+            // the scope — it reads as "the field is going" when only one polygon
+            // was asked for — but it names the right group, and it is only ever READ
+            // on the `deleteBlocked$` emission that reports the refusal: the
+            // predicate is refused before it is ever consulted with this target, and
+            // with no predicate set nothing observes it at all. A target that only
+            // ever reports a refusal cannot authorise a removal, so the overstatement
+            // is inert. The alternative was emitting nothing, which would leave a
+            // refused delete indistinguishable from a successful one on the design's
+            // only feedback channel.
+            return {
+                removing,
+                target: { group: resolved.group, feature: null },
+                unnamable: true,
+            };
+        }
+        return {
+            removing,
+            target: {
+                group: resolved.group,
+                feature: resolved.group.features[index],
+            },
+            unnamable: false,
+        };
+    }
+    /** Resolves the same features `_removeSelection()` would remove. */
+    _selectionDeletion() {
+        this._assertInitialized();
+        const removing = [];
+        this.googleMap.data.forEach((f) => {
+            if (isFeatureSelected(f)) {
+                removing.push(f);
+            }
+        });
+        if (removing.length === 0) {
+            return null;
+        }
+        return this._deletionOf(this._registry.keyOf(removing[0]), removing);
+    }
+    /** Resolves the same features `_removeFocusedFeature()` would remove. */
+    _focusedFeatureDeletion() {
+        const focused = this._focusedFeature;
+        if (focused === null) {
+            return this._selectionDeletion();
+        }
+        return this._deletionOf(this._registry.keyOf(focused), [focused]);
+    }
+    /** Resolves the same features `_removeGroup(key)` would remove. */
+    _groupDeletion(key) {
+        return this._deletionOf(key, this._registry.featuresIn(key));
+    }
+    /**
+     * Whether `removing` may be deleted: the feature-declared lock first, then
+     * the consumer's predicate.
+     *
+     * MUST stay pure. It also answers menu-render questions, which are not
+     * delete attempts — a side effect here would fire on every right-click.
+     */
+    _mayDelete(removing, target) {
+        // A feature the consumer locked against reshaping must not be removable
+        // by another route: deleting a polygon changes the map's value at least
+        // as much as reshaping it does. Same precedent as editable: false
+        // implying draggable: false in compute-feature-style.ts.
+        if (removing.some((f) => !featureAllows(f, 'editable'))) {
+            return false;
+        }
+        return this._canDelete?.(target) ?? true;
+    }
+    /**
+     * Whether a resolved deletion may proceed. The single gate every query and
+     * every command goes through.
+     *
+     * Wraps `_mayDelete` with the one refusal that cannot be phrased as a
+     * question about a target: an `unnamable` delete. Consulting the predicate
+     * there would mean LYING to it — handing it `feature: null`, which promises
+     * the whole group is about to cease to exist, for a delete that removes one
+     * polygon and leaves the rest standing. A consumer whose rule is "a field
+     * may be deleted, an individual polygon may not" answers `true` to that and
+     * loses a polygon it meant to keep. Fail closed exactly where a consumer's
+     * rule could be subverted.
+     *
+     * Only when a predicate is actually set. With none there is nobody to lie
+     * to, so there is nothing to protect — and refusing unconditionally would
+     * change 'legacy' mode's behaviour for unsupported-geometry features, which
+     * two applications depend on and this work must not drift.
+     *
+     * Pure, like `_mayDelete`: it also answers menu-render questions.
+     */
+    _mayDeleteResolved(deletion) {
+        if (deletion.unnamable && this._canDelete !== undefined) {
+            return false;
+        }
+        return this._mayDelete(deletion.removing, deletion.target);
+    }
+    /** Whether "Delete Polygon" (or the `Delete` key) may act. */
+    canDeleteFocusedFeature() {
+        if (!this.mapReady) {
+            return false;
+        }
+        const deletion = this._focusedFeatureDeletion();
+        return deletion !== null && this._mayDeleteResolved(deletion);
+    }
+    /** Whether "Delete Field" may act on `key`. */
+    canDeleteGroup(key) {
+        if (!this.mapReady) {
+            return false;
+        }
+        const deletion = this._groupDeletion(key);
+        return deletion !== null && this._mayDeleteResolved(deletion);
+    }
+    /** Whether the legacy "Delete" item (or the `Delete` key) may act. */
+    canDeleteSelection() {
+        if (!this.mapReady) {
+            return false;
+        }
+        const deletion = this._selectionDeletion();
+        return deletion !== null && this._mayDeleteResolved(deletion);
+    }
+    /**
+     * Remove every selected feature, unless `canDelete` or a feature's own
+     * `editable: false` refuses. A refused delete emits on `deleteBlocked$` and
+     * changes nothing.
+     */
+    deleteSelection() {
+        this._assertInitialized();
+        const deletion = this._selectionDeletion();
+        if (deletion !== null && !this._mayDeleteResolved(deletion)) {
+            this._deleteBlockedSubject.next(deletion.target);
+            return;
+        }
+        this._removeSelection();
+    }
     /**
      * Delete every feature in `key`'s group. Backs the grouped "Delete Field"
      * context-menu item.
@@ -1256,7 +1474,7 @@ class GoogleMapsService {
      * selected, a coincidence this design has already stopped being true once
      * before and could again.
      */
-    deleteGroup(key) {
+    _removeGroup(key) {
         this._assertInitialized();
         const mapData = this.googleMap.data;
         const wasSelected = this._selectionSubject.value?.group.key === key;
@@ -1278,6 +1496,20 @@ class GoogleMapsService {
             this._contextMenuTargetSubject.next(null);
         }
     }
+    /**
+     * Remove every feature in `key`'s group, unless `canDelete` or a feature's
+     * own `editable: false` refuses. A refused delete emits on `deleteBlocked$`
+     * and changes nothing.
+     */
+    deleteGroup(key) {
+        this._assertInitialized();
+        const deletion = this._groupDeletion(key);
+        if (deletion !== null && !this._mayDeleteResolved(deletion)) {
+            this._deleteBlockedSubject.next(deletion.target);
+            return;
+        }
+        this._removeGroup(key);
+    }
     /**
      * Whether polygon drawing mode is currently active.
      *
@@ -1601,6 +1833,14 @@ class GoogleMapsService {
     getFileInputHandler() {
         return this._fileInputHandler;
     }
+    /**
+     * Reports a file the library tried to import and could not read. Called by
+     * the import controls, not by consumers — a consumer that owns importing
+     * through `setFileInputHandler` reports its own failures.
+     */
+    notifyFileImportError(file, error) {
+        this._fileImportErrorSubject.next({ file, error });
+    }
     setInteractionMode(mode) {
         this._model =
             mode === 'grouped'
@@ -1635,6 +1875,51 @@ class GoogleMapsService {
         this._ensureLabelsOverlay();
         this._labelsOverlay?.refresh();
     }
+    /**
+     * Write `label` into `featureLabelProperty` on every feature in `key`'s
+     * group, without re-adding any data. Returns `false` when no feature
+     * carries `key`, or when no `featureLabelProperty` is configured — there is
+     * then no property to write the label into.
+     *
+     * Unlike a write through the map's `value`, this does NOT go through
+     * `setData()`, so the selection and the viewport are untouched. The
+     * repaint and the value update fall out of the data layer's own
+     * `setproperty` event, which `_initFeatureChangeListeners()` already turns
+     * into a `_labelsOverlay.refresh()` and a `MapValueSource.FeatureChange`
+     * emission.
+     *
+     * It DOES emit a value change, because the label is part of the GeoJSON and
+     * the value genuinely changed. Writing that emitted value straight back
+     * through the `value` input is inert: `MapValueManagerService.setValue`
+     * finds the serialized form identical and returns without emitting.
+     */
+    setGroupLabel(key, label) {
+        this._assertInitialized();
+        const property = this._labelProperty;
+        if (!property) {
+            if (typeof ngDevMode === 'undefined' || ngDevMode) {
+                console.warn(`[seam-google-maps] setGroupLabel("${key}") was called with no ` +
+                    `featureLabelProperty configured, so there is no property to ` +
+                    `write the label into. Nothing changed.`);
+            }
+            return false;
+        }
+        const features = this._registry.featuresIn(key);
+        if (features.length === 0) {
+            return false;
+        }
+        for (const feature of features) {
+            // `setProperty` raises `setproperty` whether or not the value differs,
+            // and each one costs a full re-serialization of the map's value. A
+            // rename typed character by character would pay that per keystroke per
+            // feature for writes that change nothing.
+            if (feature.getProperty(property) === label) {
+                continue;
+            }
+            feature.setProperty(property, label);
+        }
+        return true;
+    }
     _ensureLabelsOverlay() {
         this._assertInitialized();
         if (this._labelsOverlay) {
@@ -1886,7 +2171,7 @@ class GoogleMapsService {
      * `feature` no longer exists — `_applySelection` naturally clears to null
      * when the group is now empty, via `groupWithSources`.
      */
-    deleteFocusedFeature() {
+    _removeFocusedFeature() {
         this._assertInitialized();
         const key = this._focusedFeature
             ? this._registry.keyOf(this._focusedFeature)
@@ -1897,7 +2182,7 @@ class GoogleMapsService {
             this._focusedFeature = null;
         }
         else {
-            this.deleteSelection();
+            this._removeSelection();
         }
         this._applySelection(key, null);
         // Same reasoning as deleteGroup(): a context-menu target naming this
@@ -1907,6 +2192,20 @@ class GoogleMapsService {
             this._contextMenuTargetSubject.next(null);
         }
     }
+    /**
+     * Remove the focused polygon — or, with nothing focused, the selection —
+     * unless `canDelete` or a feature's own `editable: false` refuses. A
+     * refused delete emits on `deleteBlocked$` and changes nothing.
+     */
+    deleteFocusedFeature() {
+        this._assertInitialized();
+        const deletion = this._focusedFeatureDeletion();
+        if (deletion !== null && !this._mayDeleteResolved(deletion)) {
+            this._deleteBlockedSubject.next(deletion.target);
+            return;
+        }
+        this._removeFocusedFeature();
+    }
     /** Escape cascades: cancel a draw, then clear selection, then leave edit mode. */
     handleEscape() {
         if (this.isDrawing()) {
@@ -1955,7 +2254,7 @@ class GoogleMapsService {
             // directly. By the time that second delivery arrives (confirmed
             // against the live Storybook: consistently a few milliseconds later,
             // comfortably within one animation frame — see
-            // .superpowers/closing-click-report.md), `isDrawing()` already reads
+            // docs/superpowers/reports/closing-click-report.md), `isDrawing()` already reads
             // false, so the guard just below cannot tell it apart from a fresh
             // click on open map. `_suppressNextMapClick` exists to catch exactly
             // that echo; see its doc comment for why a `domEvent.timeStamp`
@@ -2109,7 +2408,7 @@ class GoogleMapsService {
      * Arm `_suppressNextMapClick`, and guarantee it cannot linger forever if
      * the echo it exists for never arrives — confirmed to be the normal case
      * for most real closes, and true of every synthetic/`play()`-driven draw,
-     * per .superpowers/closing-click-report.md. A `setTimeout` would "solve"
+     * per docs/superpowers/reports/closing-click-report.md. A `setTimeout` would "solve"
      * this by guessing a safe wall-clock delay, which is exactly the kind of
      * timing window this fix is trying to avoid introducing. Two
      * `requestAnimationFrame` callbacks bound the window instead: the observed
@@ -2425,7 +2724,12 @@ class TheSeamGoogleMapsUploadButtonControlComponent {
     async _importFile(file) {
         const json = await readGeoFile(file);
         this._mapValueManager.setValue(json, MapValueSource.Input);
-        this._resetInput();
+    }
+    _reportImportError(file, error) {
+        if (file === undefined) {
+            return;
+        }
+        this._googleMaps.notifyFileImportError(file, error);
     }
     _createHiddenInput() {
         const fileInputElement = this._renderer.createElement('input');
@@ -2433,16 +2737,32 @@ class TheSeamGoogleMapsUploadButtonControlComponent {
         this._renderer.setAttribute(fileInputElement, 'hidden', '');
         this._renderer.setAttribute(fileInputElement, 'accept', '.json,.geojson,.shp,.zip');
         this._listeners.push(this._renderer.listen(fileInputElement, 'change', (event) => {
-            const file = this._getFile();
+            let file;
+            try {
+                file = this._getFile();
+            }
+            catch (err) {
+                // `_getFile` refuses a multi-file selection. Report it like any
+                // other reason the chosen files could not be imported. `_getFile`
+                // has already read `files` by this point, so resetting now cannot
+                // disturb the read.
+                this._reportImportError(this._fileInputElement.files?.[0], err);
+                this._resetInput();
+                return;
+            }
             if (file === null) {
                 return;
             }
             const fileImportHandler = this._googleMaps.getFileInputHandler();
             if (fileImportHandler) {
+                // The consumer owns the file now, including reporting its failures.
                 fileImportHandler(file);
+                this._resetInput();
             }
             else {
-                this._importFile(file);
+                this._importFile(file)
+                    .catch((err) => this._reportImportError(file, err))
+                    .finally(() => this._resetInput());
             }
         }));
         return fileInputElement;
@@ -2485,6 +2805,56 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImpo
                 args: ['click', ['event']]
             }] } });
 
+/**
+ * The delete items the feature context menu offers.
+ *
+ * A refused item is not rendered at all. The caller is expected to hide the
+ * menu entirely for an empty list, so a consumer that refuses everything gets
+ * no menu rather than an empty one.
+ */
+function buildDeleteMenuItems(context) {
+    const items = [];
+    if (!context.editingEnabled) {
+        return items;
+    }
+    if (context.mode !== 'grouped') {
+        if (context.canDeleteSelection()) {
+            items.push({ label: 'Delete', action: () => context.deleteSelection() });
+        }
+        return items;
+    }
+    const target = context.target;
+    if (!target) {
+        return items;
+    }
+    const key = target.group.key;
+    // On a one-polygon field, "Delete Polygon" and "Delete Field" are the same
+    // act — the first empties the group without saying so. Offer only the one
+    // that names what happens.
+    if (target.group.features.length <= 1) {
+        if (context.canDeleteGroup(key)) {
+            items.push({
+                label: 'Delete Field',
+                action: () => context.deleteGroup(key),
+            });
+        }
+        return items;
+    }
+    if (context.canDeleteFocusedFeature()) {
+        items.push({
+            label: 'Delete Polygon',
+            action: () => context.deleteFocusedFeature(),
+        });
+    }
+    if (context.canDeleteGroup(key)) {
+        items.push({
+            label: 'Delete Field',
+            action: () => context.deleteGroup(key),
+        });
+    }
+    return items;
+}
+
 class TheSeamGoogleMapsApiLoader {
 }
 
@@ -2577,16 +2947,55 @@ class TheSeamMapFileDropComponent {
         event.preventDefault();
         event.stopPropagation();
         this._renderer.setStyle(this._elementRef.nativeElement, 'display', 'none');
-        // TODO: Show error if multiple files?
-        if (!this._isSupportedDataTransfer(event.dataTransfer)) {
+        if (!this._isSupportedDataTransferTypes(event.dataTransfer)) {
+            // Not a file drag at all — selected text, a link, an image dragged out
+            // of a page. Nobody asked for an import and there is no file to name,
+            // so this stays silent rather than reporting a failure.
+            return;
+        }
+        const files = event.dataTransfer.files;
+        if (files.length !== 1) {
+            if (files.length > 1) {
+                // Refused before any handler is consulted, exactly as the upload
+                // button's `_getFile` does: `fileImportHandler` takes a single file
+                // and cannot be handed several, so the consumer never sees these and
+                // this output is its only way to learn the drop was rejected. Same
+                // message as the button, so a consumer matching on it needs one
+                // string rather than two.
+                this._ngZone.run(() => this._googleMaps.notifyFileImportError(files[0], Error('Only one file can be imported at a time.')));
+            }
             return;
         }
         const item = event.dataTransfer.items[0];
         const file = item.getAsFile();
-        readGeoFile(file).then((json) => {
+        if (file === null) {
+            return;
+        }
+        // These listeners are registered outside Angular's zone, so re-enter it
+        // before calling back into anything that expects change detection — the
+        // consumer's handler may well render a message from here.
+        this._ngZone.run(() => this._importDroppedFile(file));
+    };
+    /**
+     * Routes a dropped file the same way the upload button routes a chosen one,
+     * so `fileImportHandler` means "the consumer owns imported files" whichever
+     * way the file arrived.
+     */
+    _importDroppedFile(file) {
+        const fileImportHandler = this._googleMaps.getFileInputHandler();
+        if (fileImportHandler) {
+            // The consumer owns the file now, including reporting its failures.
+            fileImportHandler(file);
+            return;
+        }
+        readGeoFile(file)
+            .then((json) => {
             this._mapValueManager.setValue(json, MapValueSource.Input);
+        })
+            .catch((error) => {
+            this._googleMaps.notifyFileImportError(file, error);
         });
-    };
+    }
     _handleDragEnterEvent = (event) => {
         if (!this._dropAllowed()) {
             return;
@@ -2605,9 +3014,6 @@ class TheSeamMapFileDropComponent {
     _dropAllowed() {
         return !this._globalDragInProgress;
     }
-    _isSupportedDataTransfer(dataTransfer) {
-        return dataTransfer.files.length === 1 && dataTransfer.types[0] === 'Files';
-    }
     _isSupportedDataTransferTypes(dataTransfer) {
         return dataTransfer.types[0] === 'Files';
     }
@@ -2720,7 +3126,8 @@ class TheSeamGoogleMapsComponent extends _TheSeamGoogleMapsMixinBase {
     _fileUploadControlDef = {
         component: TheSeamGoogleMapsUploadButtonControlComponent,
         data: { label: 'Import Geo File', icon: faFileImport },
-        position: 6 /* google.maps.ControlPosition.LEFT_BOTTOM */,
+        // position: 6 /* google.maps.ControlPosition.LEFT_BOTTOM */,
+        position: 7, // Below top-right fullscreen button
     };
     _reCenterControlDef = {
         component: TheSeamGoogleMapsRecenterButtonControlComponent,
@@ -2758,6 +3165,17 @@ class TheSeamGoogleMapsComponent extends _TheSeamGoogleMapsMixinBase {
     streetViewControlEnabled = false;
     allowDrawingHoleInPolygon = false;
     editingEnabled = true;
+    /**
+     * Intercepts a file the user chose or dropped, in place of the library's own
+     * import handling. Covers **both** import paths: a file picked through the
+     * upload button and one dropped onto the map (`fileDropEnabled` defaults to
+     * `true`, so setting this now also intercepts drops a consumer relying on
+     * the default previously had handled internally).
+     *
+     * Once called, the consumer owns the file, including reporting any failure
+     * in its own UI — `fileImportError` will not fire for a file handed to this
+     * handler.
+     */
     set fileImportHandler(value) {
         this._googleMaps.setFileInputHandler(value);
     }
@@ -2796,9 +3214,46 @@ class TheSeamGoogleMapsComponent extends _TheSeamGoogleMapsMixinBase {
     newGroupKeyFactory;
     /** Preselect a group. Applied on map-ready and after each external value write. */
     selectedGroupKey = null;
+    /**
+     * Vetoes a delete. Return `false` to refuse the target.
+     *
+     * `target.feature === null` means the whole group is about to cease to
+     * exist — every polygon of it is going, however the delete was asked for.
+     * A non-null `feature` means one polygon is being removed from a group that
+     * survives.
+     *
+     * **Consulted when no delete is happening.** It decides whether to render
+     * the context-menu items, so it runs on every context-menu open. A
+     * predicate that logs an attempt or flips state will do so on every
+     * right-click. It must also be deterministic for a given target, or the
+     * menu and the `Delete` key can disagree about the same target.
+     *
+     * That is a correctness warning, not a performance one. The context-menu
+     * target changes only on a right-click, a delete, and a value write, so
+     * this runs a handful of times per gesture.
+     *
+     * Passing nothing refuses nothing, which is the behaviour this component
+     * has always had.
+     */
+    canDelete;
     mapReady = new EventEmitter();
     selectionChange = new EventEmitter();
     featureHoverChange = new EventEmitter();
+    /**
+     * A delete was attempted and refused — in practice, the `Delete` key, since
+     * a refused menu item is never rendered. Emits the target that was refused
+     * so the consumer can explain why; only the consumer knows the reason.
+     */
+    deleteBlocked = new EventEmitter();
+    /**
+     * A file reached one of the import paths and could not be read — a corrupt
+     * archive, a `.zip` of something else, malformed GeoJSON. Emitted so the
+     * consumer can say so in its own UI; the library has nowhere to show it.
+     *
+     * Not emitted for a file a `fileImportHandler` took: once the consumer owns
+     * the file, it owns reporting the outcome too.
+     */
+    fileImportError = new EventEmitter();
     featureContextMenu;
     _options = {
         mapTypeControl: true,
@@ -2851,39 +3306,33 @@ class TheSeamGoogleMapsComponent extends _TheSeamGoogleMapsMixinBase {
         this._googleMaps.hover$
             .pipe(skip(1), tap((hover) => this.featureHoverChange.emit(hover)), takeUntil(this._ngUnsubscribe))
             .subscribe();
+        // No `skip(1)` here, unlike `selection$` and `hover$`: `deleteBlocked$` is
+        // a plain Subject with no replayed initial value to drop.
+        this._googleMaps.deleteBlocked$
+            .pipe(tap((target) => this.deleteBlocked.emit(target)), takeUntil(this._ngUnsubscribe))
+            .subscribe();
+        // As with `deleteBlocked$`, a plain Subject with nothing to replay, so no
+        // `skip(1)`.
+        this._googleMaps.fileImportError$
+            .pipe(tap((value) => this.fileImportError.emit(value)), takeUntil(this._ngUnsubscribe))
+            .subscribe();
         this._contextMenuItems$ = combineLatest([
             this._googleMaps.editingEnabled$,
-            // The RIGHT-CLICKED feature's group. In 'grouped' mode the menu now
-            // only opens when that group is already the selection (see
-            // `GroupedInteractionModel.allowsContextMenu()`), so this and
-            // `selection$` always agree here — but this is still the one that
-            // names what "Delete Field" is conceptually acting on, independent of
-            // that coincidence. See `contextMenuTarget$`'s doc comment.
+            // The RIGHT-CLICKED feature's group — what "Delete Field" is
+            // conceptually acting on, independent of what happens to be selected.
+            // See `contextMenuTarget$`'s doc comment.
             this._googleMaps.contextMenuTarget$,
-        ]).pipe(map(([enabled, target]) => {
-            const items = [];
-            if (!enabled) {
-                return items;
-            }
-            if (this.interactionMode === 'grouped') {
-                items.push({
-                    label: 'Delete Polygon',
-                    action: () => this._googleMaps.deleteFocusedFeature(),
-                });
-                if (target && target.group.features.length > 1) {
-                    items.push({
-                        label: 'Delete Field',
-                        action: () => this._googleMaps.deleteGroup(target.group.key),
-                    });
-                }
-                return items;
-            }
-            items.push({
-                label: 'Delete',
-                action: () => this._onClickDeleteFeature(),
-            });
-            return items;
-        }), tap((items) => {
+        ]).pipe(map(([editingEnabled, target]) => buildDeleteMenuItems({
+            mode: this.interactionMode,
+            editingEnabled,
+            target,
+            canDeleteFocusedFeature: () => this._googleMaps.canDeleteFocusedFeature(),
+            canDeleteGroup: (key) => this._googleMaps.canDeleteGroup(key),
+            canDeleteSelection: () => this._googleMaps.canDeleteSelection(),
+            deleteFocusedFeature: () => this._googleMaps.deleteFocusedFeature(),
+            deleteGroup: (key) => this._googleMaps.deleteGroup(key),
+            deleteSelection: () => this._googleMaps.deleteSelection(),
+        })), tap((items) => {
             if (items.length === 0) {
                 this._googleMaps.setFeatureContextMenu(null);
             }
@@ -2985,6 +3434,9 @@ class TheSeamGoogleMapsComponent extends _TheSeamGoogleMapsMixinBase {
         if (Object.prototype.hasOwnProperty.call(changes, 'selectedGroupKey')) {
             this._applySelectedGroupKey();
         }
+        if (Object.prototype.hasOwnProperty.call(changes, 'canDelete')) {
+            this._googleMaps.setCanDelete(this.canDelete);
+        }
         if (Object.prototype.hasOwnProperty.call(changes, 'featureLabelProperty')) {
             this._googleMaps.setLabelProperty(this.featureLabelProperty);
         }
@@ -3058,9 +3510,6 @@ class TheSeamGoogleMapsComponent extends _TheSeamGoogleMapsMixinBase {
             this.idleListener?.remove();
         });
     }
-    _onClickDeleteFeature() {
-        this._googleMaps.deleteSelection();
-    }
     // The service delegates below guard on `mapReady` themselves, the same way
     // `_applySelectedGroupKey()` already does for the declarative
     // `selectedGroupKey` input. Their service-side counterparts call
@@ -3101,6 +3550,19 @@ class TheSeamGoogleMapsComponent extends _TheSeamGoogleMapsMixinBase {
         }
         return this._googleMaps.getGroups();
     }
+    /**
+     * Set a group's label text in place. Returns false when no such group
+     * exists, or when no `featureLabelProperty` is set.
+     *
+     * Does not clear the selection or re-fit the viewport, so it is safe to
+     * call while the user is renaming the very group being displayed.
+     */
+    setGroupLabel(key, label) {
+        if (!this._googleMaps.mapReady) {
+            return false;
+        }
+        return this._googleMaps.setGroupLabel(key, label);
+    }
     setEditMode(enabled) {
         this._googleMaps.setEditMode(enabled);
     }
@@ -3108,7 +3570,7 @@ class TheSeamGoogleMapsComponent extends _TheSeamGoogleMapsMixinBase {
         return this._googleMaps.isEditMode();
     }
     static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "20.3.15", ngImport: i0, type: TheSeamGoogleMapsComponent, deps: [{ token: i0.ElementRef }, { token: i1.FocusMonitor }, { token: GoogleMapsService }, { token: MapValueManagerService }, { token: TheSeamGoogleMapsApiLoader }], target: i0.ɵɵFactoryTarget.Component });
-    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.3.15", type: TheSeamGoogleMapsComponent, isStandalone: false, selector: "seam-google-maps", inputs: { disabled: "disabled", value: "value", tabIndex: "tabIndex", fileDropEnabled: "fileDropEnabled", fileUploadControlEnabled: "fileUploadControlEnabled", fullscreenControlEnabled: "fullscreenControlEnabled", reCenterControlEnabled: "reCenterControlEnabled", mapTypeControlEnabled: "mapTypeControlEnabled", streetViewControlEnabled: "streetViewControlEnabled", allowDrawingHoleInPolygon: "allowDrawingHoleInPolygon", editingEnabled: "editingEnabled", fileImportHandler: "fileImportHandler", zoom: "zoom", longitude: "longitude", latitude: "latitude", padding: "padding", interactionMode: "interactionMode", featureGroupProperty: "featureGroupProperty", featureLabelProperty: "featureLabelProperty", newGroupKeyFactory: "newGroupKeyFactory", selectedGroupKey: "selectedGroupKey" }, outputs: { mapReady: "mapReady", selectionChange: "selectionChange", featureHoverChange: "featureHoverChange" }, host: { properties: { "attr.disabled": "this._attrDisabled", "attr.tabindex": "this._attrTabIndex" } }, providers: [
+    static ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "20.3.15", type: TheSeamGoogleMapsComponent, isStandalone: false, selector: "seam-google-maps", inputs: { disabled: "disabled", value: "value", tabIndex: "tabIndex", fileDropEnabled: "fileDropEnabled", fileUploadControlEnabled: "fileUploadControlEnabled", fullscreenControlEnabled: "fullscreenControlEnabled", reCenterControlEnabled: "reCenterControlEnabled", mapTypeControlEnabled: "mapTypeControlEnabled", streetViewControlEnabled: "streetViewControlEnabled", allowDrawingHoleInPolygon: "allowDrawingHoleInPolygon", editingEnabled: "editingEnabled", fileImportHandler: "fileImportHandler", zoom: "zoom", longitude: "longitude", latitude: "latitude", padding: "padding", interactionMode: "interactionMode", featureGroupProperty: "featureGroupProperty", featureLabelProperty: "featureLabelProperty", newGroupKeyFactory: "newGroupKeyFactory", selectedGroupKey: "selectedGroupKey", canDelete: "canDelete" }, outputs: { mapReady: "mapReady", selectionChange: "selectionChange", featureHoverChange: "featureHoverChange", deleteBlocked: "deleteBlocked", fileImportError: "fileImportError" }, host: { properties: { "attr.disabled": "this._attrDisabled", "attr.tabindex": "this._attrTabIndex" } }, providers: [
             MapValueManagerService,
             GoogleMapsService,
             { provide: MAP_CONTROLS_SERVICE, useClass: GoogleMapsControlsService },
@@ -3117,7 +3579,7 @@ class TheSeamGoogleMapsComponent extends _TheSeamGoogleMapsMixinBase {
                 useExisting: forwardRef(() => TheSeamGoogleMapsComponent),
                 multi: true,
             },
-        ], viewQueries: [{ propertyName: "featureContextMenu", first: true, predicate: ["featureContextMenu"], descendants: true, read: MenuComponent, static: true }], exportAs: ["seamGoogleMaps"], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<ng-container *ngIf=\"_gmApiLoaded | async\">\n  <google-map\n    height=\"100%\"\n    width=\"100%\"\n    [center]=\"{ lat: latitude, lng: longitude }\"\n    [zoom]=\"zoom\"\n    [options]=\"_options\"\n    (mapInitialized)=\"_onMapReady($any($event))\"\n  >\n  </google-map>\n</ng-container>\n<seam-menu #featureContextMenu>\n  <button\n    seamMenuItem\n    *ngFor=\"let item of _contextMenuItems$ | async\"\n    (click)=\"item.action(item)\"\n  >\n    {{ item.label }}\n  </button>\n</seam-menu>\n<seam-map-file-drop *ngIf=\"fileDropEnabled\"></seam-map-file-drop>\n\n<seam-map-control\n  *ngIf=\"fileUploadControlEnabled\"\n  [def]=\"_fileUploadControlDef\"\n></seam-map-control>\n<seam-map-control\n  *ngIf=\"reCenterControlEnabled\"\n  [def]=\"_reCenterControlDef\"\n></seam-map-control>\n<seam-map-control\n  *ngIf=\"editingEnabled\"\n  [def]=\"_drawControlDef\"\n></seam-map-control>\n", styles: [":host{display:block;position:relative;height:400px;width:100%}:host.show-focus-border.cdk-focused{outline:0;box-shadow:0 0 0 .2rem #357ebd40}:host.show-focus-border[disabled]{opacity:.65}:host ::ng-deep .seam-map-feature-label{color:#fff;font-size:.75rem;font-weight:600;text-shadow:0 0 3px rgba(0,0,0,.9),0 0 6px rgba(0,0,0,.7);-webkit-user-select:none;user-select:none}\n"], dependencies: [{ kind: "directive", type: i5.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i6.MenuComponent, selector: "seam-menu", inputs: ["menuClass", "baseWidth", "animationType"], outputs: ["closed"], exportAs: ["seamMenu"] }, { kind: "component", type: i6.MenuItemComponent, selector: "[seamMenuItem]", inputs: ["disabled", "role", "icon", "iconClass", "sublevelIcon", "subLevelIconClass", "badgeText", "badgeTheme"], exportAs: ["seamMenuItem"] }, { kind: "component", type: i7.GoogleMap, selector: "google-map", inputs: ["height", "width", "mapId", "mapTypeId", "center", "zoom", "options"], outputs: ["mapInitialized", "authFailure", "boundsChanged", "centerChanged", "mapClick", "mapDblclick", "mapDrag", "mapDragend", "mapDragstart", "headingChanged", "idle", "maptypeidChanged", "mapMousemove", "mapMouseout", "mapMouseover", "projectionChanged", "mapRightclick", "tilesloaded", "tiltChanged", "zoomChanged"], exportAs: ["googleMap"] }, { kind: "component", type: TheSeamMapFileDropComponent, selector: "seam-map-file-drop" }, { kind: "component", type: TheSeamMapsControlComponent, selector: "seam-map-control", inputs: ["def"] }, { kind: "pipe", type: i5.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
+        ], viewQueries: [{ propertyName: "featureContextMenu", first: true, predicate: ["featureContextMenu"], descendants: true, read: MenuComponent, static: true }], exportAs: ["seamGoogleMaps"], usesInheritance: true, usesOnChanges: true, ngImport: i0, template: "<ng-container *ngIf=\"_gmApiLoaded | async\">\n  <google-map\n    height=\"100%\"\n    width=\"100%\"\n    [center]=\"{ lat: latitude, lng: longitude }\"\n    [zoom]=\"zoom\"\n    [options]=\"_options\"\n    (mapInitialized)=\"_onMapReady($any($event))\"\n  >\n  </google-map>\n</ng-container>\n<seam-menu #featureContextMenu>\n  <button\n    seamMenuItem\n    *ngFor=\"let item of _contextMenuItems$ | async\"\n    (click)=\"item.action()\"\n  >\n    {{ item.label }}\n  </button>\n</seam-menu>\n<seam-map-file-drop *ngIf=\"fileDropEnabled\"></seam-map-file-drop>\n\n<seam-map-control\n  *ngIf=\"fileUploadControlEnabled\"\n  [def]=\"_fileUploadControlDef\"\n></seam-map-control>\n<seam-map-control\n  *ngIf=\"reCenterControlEnabled\"\n  [def]=\"_reCenterControlDef\"\n></seam-map-control>\n<seam-map-control\n  *ngIf=\"editingEnabled\"\n  [def]=\"_drawControlDef\"\n></seam-map-control>\n", styles: [":host{display:block;position:relative;height:400px;width:100%}:host.show-focus-border.cdk-focused{outline:0;box-shadow:0 0 0 .2rem #357ebd40}:host.show-focus-border[disabled]{opacity:.65}:host ::ng-deep .seam-map-feature-label{color:#fff;font-size:.75rem;font-weight:600;text-shadow:0 0 3px rgba(0,0,0,.9),0 0 6px rgba(0,0,0,.7);-webkit-user-select:none;user-select:none}\n"], dependencies: [{ kind: "directive", type: i5.NgForOf, selector: "[ngFor][ngForOf]", inputs: ["ngForOf", "ngForTrackBy", "ngForTemplate"] }, { kind: "directive", type: i5.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i6.MenuComponent, selector: "seam-menu", inputs: ["menuClass", "baseWidth", "animationType"], outputs: ["closed"], exportAs: ["seamMenu"] }, { kind: "component", type: i6.MenuItemComponent, selector: "[seamMenuItem]", inputs: ["disabled", "role", "icon", "iconClass", "sublevelIcon", "subLevelIconClass", "badgeText", "badgeTheme"], exportAs: ["seamMenuItem"] }, { kind: "component", type: i7.GoogleMap, selector: "google-map", inputs: ["height", "width", "mapId", "mapTypeId", "center", "zoom", "options"], outputs: ["mapInitialized", "authFailure", "boundsChanged", "centerChanged", "mapClick", "mapDblclick", "mapDrag", "mapDragend", "mapDragstart", "headingChanged", "idle", "maptypeidChanged", "mapMousemove", "mapMouseout", "mapMouseover", "projectionChanged", "mapRightclick", "tilesloaded", "tiltChanged", "zoomChanged"], exportAs: ["googleMap"] }, { kind: "component", type: TheSeamMapFileDropComponent, selector: "seam-map-file-drop" }, { kind: "component", type: TheSeamMapsControlComponent, selector: "seam-map-control", inputs: ["def"] }, { kind: "pipe", type: i5.AsyncPipe, name: "async" }], changeDetection: i0.ChangeDetectionStrategy.OnPush });
 }
 __decorate([
     InputBoolean()
@@ -3163,7 +3625,7 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImpo
                             useExisting: forwardRef(() => TheSeamGoogleMapsComponent),
                             multi: true,
                         },
-                    ], changeDetection: ChangeDetectionStrategy.OnPush, exportAs: 'seamGoogleMaps', standalone: false, template: "<ng-container *ngIf=\"_gmApiLoaded | async\">\n  <google-map\n    height=\"100%\"\n    width=\"100%\"\n    [center]=\"{ lat: latitude, lng: longitude }\"\n    [zoom]=\"zoom\"\n    [options]=\"_options\"\n    (mapInitialized)=\"_onMapReady($any($event))\"\n  >\n  </google-map>\n</ng-container>\n<seam-menu #featureContextMenu>\n  <button\n    seamMenuItem\n    *ngFor=\"let item of _contextMenuItems$ | async\"\n    (click)=\"item.action(item)\"\n  >\n    {{ item.label }}\n  </button>\n</seam-menu>\n<seam-map-file-drop *ngIf=\"fileDropEnabled\"></seam-map-file-drop>\n\n<seam-map-control\n  *ngIf=\"fileUploadControlEnabled\"\n  [def]=\"_fileUploadControlDef\"\n></seam-map-control>\n<seam-map-control\n  *ngIf=\"reCenterControlEnabled\"\n  [def]=\"_reCenterControlDef\"\n></seam-map-control>\n<seam-map-control\n  *ngIf=\"editingEnabled\"\n  [def]=\"_drawControlDef\"\n></seam-map-control>\n", styles: [":host{display:block;position:relative;height:400px;width:100%}:host.show-focus-border.cdk-focused{outline:0;box-shadow:0 0 0 .2rem #357ebd40}:host.show-focus-border[disabled]{opacity:.65}:host ::ng-deep .seam-map-feature-label{color:#fff;font-size:.75rem;font-weight:600;text-shadow:0 0 3px rgba(0,0,0,.9),0 0 6px rgba(0,0,0,.7);-webkit-user-select:none;user-select:none}\n"] }]
+                    ], changeDetection: ChangeDetectionStrategy.OnPush, exportAs: 'seamGoogleMaps', standalone: false, template: "<ng-container *ngIf=\"_gmApiLoaded | async\">\n  <google-map\n    height=\"100%\"\n    width=\"100%\"\n    [center]=\"{ lat: latitude, lng: longitude }\"\n    [zoom]=\"zoom\"\n    [options]=\"_options\"\n    (mapInitialized)=\"_onMapReady($any($event))\"\n  >\n  </google-map>\n</ng-container>\n<seam-menu #featureContextMenu>\n  <button\n    seamMenuItem\n    *ngFor=\"let item of _contextMenuItems$ | async\"\n    (click)=\"item.action()\"\n  >\n    {{ item.label }}\n  </button>\n</seam-menu>\n<seam-map-file-drop *ngIf=\"fileDropEnabled\"></seam-map-file-drop>\n\n<seam-map-control\n  *ngIf=\"fileUploadControlEnabled\"\n  [def]=\"_fileUploadControlDef\"\n></seam-map-control>\n<seam-map-control\n  *ngIf=\"reCenterControlEnabled\"\n  [def]=\"_reCenterControlDef\"\n></seam-map-control>\n<seam-map-control\n  *ngIf=\"editingEnabled\"\n  [def]=\"_drawControlDef\"\n></seam-map-control>\n", styles: [":host{display:block;position:relative;height:400px;width:100%}:host.show-focus-border.cdk-focused{outline:0;box-shadow:0 0 0 .2rem #357ebd40}:host.show-focus-border[disabled]{opacity:.65}:host ::ng-deep .seam-map-feature-label{color:#fff;font-size:.75rem;font-weight:600;text-shadow:0 0 3px rgba(0,0,0,.9),0 0 6px rgba(0,0,0,.7);-webkit-user-select:none;user-select:none}\n"] }]
         }], ctorParameters: () => [{ type: i0.ElementRef }, { type: i1.FocusMonitor }, { type: GoogleMapsService }, { type: MapValueManagerService }, { type: TheSeamGoogleMapsApiLoader }], propDecorators: { value: [{
                 type: Input
             }], tabIndex: [{
@@ -3210,12 +3672,18 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImpo
                 type: Input
             }], selectedGroupKey: [{
                 type: Input
+            }], canDelete: [{
+                type: Input
             }], mapReady: [{
                 type: Output
             }], selectionChange: [{
                 type: Output
             }], featureHoverChange: [{
                 type: Output
+            }], deleteBlocked: [{
+                type: Output
+            }], fileImportError: [{
+                type: Output
             }], featureContextMenu: [{
                 type: ViewChild,
                 args: ['featureContextMenu', { static: true, read: MenuComponent }]
@@ -3796,5 +4264,5 @@ i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "20.3.15", ngImpo
  * Generated bundle index. Do not edit.
  */
 
-export { AppFeaturePropertyName, FEATURE_STYLE_OPTIONS_DEFAULT, FEATURE_STYLE_OPTIONS_SELECTED, FEATURE_STYLE_OVERRIDE_OPTIONS_HOVERED, GoogleMapsContextMenu, GoogleMapsControlsService, GoogleMapsService, MAP_CONTROLS_SERVICE, MAP_CONTROL_DATA, MapControlRef, MapValueManagerService, MapValueSource, SEAM_GOOGLE_PLACES_AUTOCOMPLETE_DEFAULT_OPTIONS, SUPPORTED_PROPERTY_STYLE_OPTIONS, THESEAM_LAZY_MAPS_API_CONFIG, TheSeamGoogleMapsApiLoader, TheSeamGoogleMapsComponent, TheSeamGoogleMapsModule, TheSeamGoogleMapsPlacesAutoCompleteComponent, TheSeamGoogleMapsPlacesAutocompleteDirective, TheSeamGoogleMapsRecenterButtonControlComponent, TheSeamGoogleMapsUploadButtonControlComponent, TheSeamLazyMapsApiLoader, TheSeamMapFileDropComponent, TheSeamMapsControlComponent, TheSeamNoopGoogleMapsAPILoader, applyHoleToFeature, computeFeatureHoverStyle, computeFeatureStyle, createFeatureChangeObservable, dataMultiPolygonFromGeoJson, dataPolygonFromGeoJson, geoJsonFeatureFromDataFeature, geoJsonPolygonFromDataFeature, getBoundsWithAllFeatures, getFeatureBounds, getFeatureCenter, getFeaturesCount, getHoveredStyleOptionsDefinedByFeature, getSelectedStyleOptionsDefinedByFeature, getStyleOptionsDefinedByFeature, isAppFeatureProperty, isFeatureSelected, mergeStyleOptions, polygonCoordinates, polygonHasValidPathsLengths, polygonsFromDataFeature, removeAllFeatures, setFeatureSelected, stripAppFeaturePropertiesFromJson };
+export { AppFeaturePropertyName, FEATURE_STYLE_OPTIONS_DEFAULT, FEATURE_STYLE_OPTIONS_SELECTED, FEATURE_STYLE_OVERRIDE_OPTIONS_HOVERED, GoogleMapsContextMenu, GoogleMapsControlsService, GoogleMapsService, MAP_CONTROLS_SERVICE, MAP_CONTROL_DATA, MapControlRef, MapValueManagerService, MapValueSource, SEAM_GOOGLE_PLACES_AUTOCOMPLETE_DEFAULT_OPTIONS, SUPPORTED_PROPERTY_STYLE_OPTIONS, THESEAM_LAZY_MAPS_API_CONFIG, TheSeamGoogleMapsApiLoader, TheSeamGoogleMapsComponent, TheSeamGoogleMapsModule, TheSeamGoogleMapsPlacesAutoCompleteComponent, TheSeamGoogleMapsPlacesAutocompleteDirective, TheSeamGoogleMapsRecenterButtonControlComponent, TheSeamGoogleMapsUploadButtonControlComponent, TheSeamLazyMapsApiLoader, TheSeamMapFileDropComponent, TheSeamMapsControlComponent, TheSeamNoopGoogleMapsAPILoader, applyHoleToFeature, buildDeleteMenuItems, computeFeatureHoverStyle, computeFeatureStyle, createFeatureChangeObservable, dataMultiPolygonFromGeoJson, dataPolygonFromGeoJson, featureAllows, geoJsonFeatureFromDataFeature, geoJsonPolygonFromDataFeature, getBoundsWithAllFeatures, getFeatureBounds, getFeatureCenter, getFeaturesCount, getHoveredStyleOptionsDefinedByFeature, getSelectedStyleOptionsDefinedByFeature, getStyleOptionsDefinedByFeature, isAppFeatureProperty, isFeatureSelected, mergeStyleOptions, polygonCoordinates, polygonHasValidPathsLengths, polygonsFromDataFeature, removeAllFeatures, setFeatureSelected, stripAppFeaturePropertiesFromJson };
 //# sourceMappingURL=theseam-ui-common-google-maps.mjs.map