@deck.gl-community/editable-layers 9.2.0-beta.4 → 9.2.0-beta.6

package/dist/index.cjs

@@ -2938,48 +2938,53 @@ var DrawLineStringMode = class extends GeoJsonEditMode {
 // dist/edit-modes/draw-polygon-mode.js
 var import_line_intersect2 = __toESM(require("@turf/line-intersect"), 1);
 var import_helpers9 = require("@turf/helpers");
+var import_boolean_within = __toESM(require("@turf/boolean-within"), 1);
 var DrawPolygonMode = class extends GeoJsonEditMode {
+  holeSequence = [];
+  isDrawingHole = false;
   createTentativeFeature(props) {
     const { lastPointerMoveEvent } = props;
     const clickSequence = this.getClickSequence();
+    const holeSequence = this.holeSequence;
     const lastCoords = lastPointerMoveEvent ? [lastPointerMoveEvent.mapCoords] : [];
-    let tentativeFeature;
-    if (clickSequence.length === 1 || clickSequence.length === 2) {
-      tentativeFeature = {
-        type: "Feature",
-        properties: {
-          guideType: "tentative"
-        },
-        geometry: {
-          type: "LineString",
-          coordinates: [...clickSequence, ...lastCoords]
-        }
+    let geometry;
+    if (this.isDrawingHole && holeSequence.length > 1) {
+      geometry = {
+        type: "Polygon",
+        coordinates: [
+          [...clickSequence, clickSequence[0]],
+          [...holeSequence, ...lastCoords, holeSequence[0]]
+        ]
       };
     } else if (clickSequence.length > 2) {
-      tentativeFeature = {
-        type: "Feature",
-        properties: {
-          guideType: "tentative"
-        },
-        geometry: {
-          type: "Polygon",
-          coordinates: [[...clickSequence, ...lastCoords, clickSequence[0]]]
-        }
+      geometry = {
+        type: "Polygon",
+        coordinates: [[...clickSequence, ...lastCoords, clickSequence[0]]]
+      };
+    } else {
+      geometry = {
+        type: "LineString",
+        coordinates: [...clickSequence, ...lastCoords]
       };
     }
-    return tentativeFeature;
+    return {
+      type: "Feature",
+      properties: {
+        guideType: "tentative"
+      },
+      geometry
+    };
   }
   getGuides(props) {
-    const clickSequence = this.getClickSequence();
     const guides = {
       type: "FeatureCollection",
       features: []
     };
-    const tentativeFeature = this.createTentativeFeature(props);
-    if (tentativeFeature) {
-      guides.features.push(tentativeFeature);
-    }
-    const editHandles = clickSequence.map((clickedCoord, index) => ({
+    const tentative = this.createTentativeFeature(props);
+    if (tentative)
+      guides.features.push(tentative);
+    const sequence = this.isDrawingHole ? this.holeSequence : this.getClickSequence();
+    const handles = sequence.map((coord, index) => ({
       type: "Feature",
       properties: {
         guideType: "editHandle",
@@ -2989,51 +2994,55 @@ var DrawPolygonMode = class extends GeoJsonEditMode {
       },
       geometry: {
         type: "Point",
-        coordinates: clickedCoord
+        coordinates: coord
       }
     }));
-    guides.features.push(...editHandles);
+    guides.features.push(...handles);
     return guides;
   }
-  finishDrawing(props) {
-    const clickSequence = this.getClickSequence();
-    if (clickSequence.length > 2) {
-      const polygonToAdd = {
-        type: "Polygon",
-        coordinates: [[...clickSequence, clickSequence[0]]]
-      };
-      this.resetClickSequence();
-      const editAction = this.getAddFeatureOrBooleanPolygonAction(polygonToAdd, props);
-      if (editAction) {
-        props.onEdit(editAction);
-      }
-    }
-  }
-  // eslint-disable-next-line complexity
+  // eslint-disable-next-line complexity, max-statements
   handleClick(event, props) {
     const { picks } = event;
     const clickedEditHandle = getPickedEditHandle(picks);
     const clickSequence = this.getClickSequence();
-    let overlappingLines = false;
-    if (clickSequence.length > 2 && props.modeConfig && props.modeConfig.preventOverlappingLines) {
-      const currentLine = (0, import_helpers9.lineString)([
-        clickSequence[clickSequence.length - 1],
-        event.mapCoords
-      ]);
-      const otherLines = (0, import_helpers9.lineString)([...clickSequence.slice(0, clickSequence.length - 1)]);
-      const intersectingPoints = (0, import_line_intersect2.default)(currentLine, otherLines);
-      if (intersectingPoints.features.length > 0) {
-        overlappingLines = true;
+    const coords = event.mapCoords;
+    if (!this.isDrawingHole && clickSequence.length > 2 && clickedEditHandle && Array.isArray(clickedEditHandle.properties.positionIndexes) && (clickedEditHandle.properties.positionIndexes[0] === 0 || clickedEditHandle.properties.positionIndexes[0] === clickSequence.length - 1)) {
+      this.finishDrawing(props);
+      return;
+    }
+    if (!this.isDrawingHole && clickSequence.length > 2) {
+      if (isNearFirstPoint(coords, clickSequence[0])) {
+        this.finishDrawing(props);
+        this.resetClickSequence();
+        return;
       }
     }
+    if (this.isDrawingHole) {
+      const current = this.holeSequence;
+      current.push(coords);
+      if (current.length > 2) {
+        const poly = {
+          type: "Polygon",
+          coordinates: [
+            [...clickSequence, clickSequence[0]],
+            [...current, current[0]]
+          ]
+        };
+        this.resetClickSequence();
+        this.holeSequence = [];
+        this.isDrawingHole = false;
+        const editAction = this.getAddFeatureOrBooleanPolygonAction(poly, props);
+        if (editAction)
+          props.onEdit(editAction);
+      }
+      return;
+    }
     let positionAdded = false;
-    if (!clickedEditHandle && !overlappingLines) {
+    if (!clickedEditHandle) {
       this.addClickSequence(event);
       positionAdded = true;
     }
-    if (clickSequence.length > 2 && clickedEditHandle && Array.isArray(clickedEditHandle.properties.positionIndexes) && (clickedEditHandle.properties.positionIndexes[0] === 0 || clickedEditHandle.properties.positionIndexes[0] === clickSequence.length - 1)) {
-      this.finishDrawing(props);
-    } else if (positionAdded) {
+    if (positionAdded) {
       props.onEdit({
         // data is the same
         updatedData: props.data,
@@ -3044,16 +3053,19 @@ var DrawPolygonMode = class extends GeoJsonEditMode {
       });
     }
   }
-  handleDoubleClick(event, props) {
+  handleDoubleClick(_event, props) {
     this.finishDrawing(props);
+    this.resetClickSequence();
   }
   handleKeyUp(event, props) {
     if (event.key === "Enter") {
       this.finishDrawing(props);
+      this.resetClickSequence();
     } else if (event.key === "Escape") {
       this.resetClickSequence();
+      this.holeSequence = [];
+      this.isDrawingHole = false;
       props.onEdit({
-        // Because the new drawing feature is dropped, so the data will keep as the same.
         updatedData: props.data,
         editType: "cancelFeature",
         editContext: {}
@@ -3064,7 +3076,119 @@ var DrawPolygonMode = class extends GeoJsonEditMode {
     props.onUpdateCursor("cell");
     super.handlePointerMove(event, props);
   }
+  // eslint-disable-next-line max-statements, complexity
+  finishDrawing(props) {
+    const clickSequence = this.getClickSequence();
+    const polygon3 = [...clickSequence, clickSequence[0]];
+    const newPolygon = (0, import_helpers9.polygon)([polygon3]);
+    const canAddHole = canAddHoleToPolygon(props);
+    const canOverlap = canPolygonOverlap(props);
+    if (!canOverlap) {
+      const overlapping = (0, import_line_intersect2.default)(newPolygon, newPolygon).features.filter((intersection) => !newPolygon.geometry.coordinates[0].some((coord) => coord[0] === intersection.geometry.coordinates[0] && coord[1] === intersection.geometry.coordinates[1]));
+      if (overlapping.length > 0) {
+        props.onEdit({
+          updatedData: props.data,
+          editType: "invalidPolygon",
+          editContext: { reason: "overlaps" }
+        });
+        this.resetClickSequence();
+        return;
+      }
+    }
+    if (canAddHole) {
+      const holeResult = this.tryAddHoleToExistingPolygon(newPolygon, polygon3, props);
+      if (holeResult.handled) {
+        this.resetClickSequence();
+        return;
+      }
+    }
+    const editAction = this.getAddFeatureOrBooleanPolygonAction({
+      type: "Polygon",
+      coordinates: [[...this.getClickSequence(), this.getClickSequence()[0]]]
+    }, props);
+    if (editAction)
+      props.onEdit(editAction);
+    this.resetClickSequence();
+    return;
+  }
+  tryAddHoleToExistingPolygon(newPolygon, polygon3, props) {
+    for (const [featureIndex, feature] of props.data.features.entries()) {
+      if (feature.geometry.type === "Polygon") {
+        const result = this.validateAndCreateHole(feature, featureIndex, newPolygon, polygon3, props);
+        if (result.handled) {
+          return result;
+        }
+      }
+    }
+    return { handled: false };
+  }
+  validateAndCreateHole(feature, featureIndex, newPolygon, polygon3, props) {
+    const outer = (0, import_helpers9.polygon)(feature.geometry.coordinates);
+    for (let i = 1; i < feature.geometry.coordinates.length; i++) {
+      const hole = (0, import_helpers9.polygon)([feature.geometry.coordinates[i]]);
+      const intersection = (0, import_line_intersect2.default)(hole, newPolygon);
+      if (intersection.features.length > 0) {
+        props.onEdit({
+          updatedData: props.data,
+          editType: "invalidHole",
+          editContext: { reason: "intersects-existing-hole" }
+        });
+        return { handled: true };
+      }
+      if ((0, import_boolean_within.default)(hole, newPolygon) || (0, import_boolean_within.default)(newPolygon, hole)) {
+        props.onEdit({
+          updatedData: props.data,
+          editType: "invalidHole",
+          editContext: { reason: "contains-or-contained-by-existing-hole" }
+        });
+        return { handled: true };
+      }
+    }
+    const intersectionWithOuter = (0, import_line_intersect2.default)(outer, newPolygon);
+    if (intersectionWithOuter.features.length > 0) {
+      props.onEdit({
+        updatedData: props.data,
+        editType: "invalidPolygon",
+        editContext: { reason: "intersects-existing-polygon" }
+      });
+      return { handled: true };
+    }
+    if ((0, import_boolean_within.default)(outer, newPolygon)) {
+      props.onEdit({
+        updatedData: props.data,
+        editType: "invalidPolygon",
+        editContext: { reason: "contains-existing-polygon" }
+      });
+      return { handled: true };
+    }
+    if ((0, import_boolean_within.default)(newPolygon, outer)) {
+      const updatedData = new ImmutableFeatureCollection(props.data).replaceGeometry(featureIndex, {
+        ...feature.geometry,
+        coordinates: [...feature.geometry.coordinates, polygon3]
+      }).getObject();
+      props.onEdit({
+        updatedData,
+        editType: "addHole",
+        editContext: { hole: newPolygon.geometry }
+      });
+      return { handled: true };
+    }
+    return { handled: false };
+  }
 };
+function isNearFirstPoint(click, first, threshold = 1e-4) {
+  const dx = click[0] - first[0];
+  const dy = click[1] - first[1];
+  return dx * dx + dy * dy < threshold * threshold;
+}
+function canAddHoleToPolygon(props) {
+  var _a;
+  return ((_a = props.modeConfig) == null ? void 0 : _a.allowHoles) ?? false;
+}
+function canPolygonOverlap(props) {
+  var _a;
+  return ((_a = props.modeConfig) == null ? void 0 : _a.allowSelfIntersection) ?? false;
+}
 
 // dist/edit-modes/draw-rectangle-mode.js
 var import_bbox_polygon4 = __toESM(require("@turf/bbox-polygon"), 1);