@accelint/map-toolkit 0.6.0 → 1.1.0

package/dist/deckgl/shapes/edit-shape-layer/modes/scale-mode-with-free-transform.js

@@ -0,0 +1,289 @@
+/*
+ * Copyright 2025 Hypergiant Galactic Systems Inc. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+
+import { ScaleMode } from "@deck.gl-community/editable-layers";
+
+//#region src/deckgl/shapes/edit-shape-layer/modes/scale-mode-with-free-transform.ts
+/**
+* Extends ScaleMode to support non-uniform (free) scaling.
+*
+* ## Features
+* - Default: Free scaling - can stretch/squish in any direction
+* - With modeConfig.lockScaling = true: Uniform scaling (maintains aspect ratio)
+*
+* ## How Non-Uniform Scaling Works
+*
+* Non-uniform scaling applies separate X and Y scale factors based on cursor
+* movement relative to the opposite corner (the "origin" or anchor point).
+*
+* ```
+*   Origin (opposite corner)           Drag Handle (start)
+*   ●───────────────────────────────────●
+*   │                                   │
+*   │     startDelta = start - origin   │
+*   │     currentDelta = current - origin
+*   │                                   │
+*   │     scaleX = currentDeltaX / startDeltaX
+*   │     scaleY = currentDeltaY / startDeltaY
+*   │                                   │
+*   ●───────────────────────────────────● Cursor (current)
+* ```
+*
+* Each coordinate is transformed: `newCoord = origin + (oldCoord - origin) × scale`
+*
+* ## Why We Override Parent's Uniform Scaling
+*
+* The parent ScaleMode calculates uniform scale factors in screen coordinates,
+* which can distort rotated shapes. We calculate our own uniform factor using
+* vector projection to ensure the corner follows the cursor's projection onto
+* the original drag line, preserving shape orientation.
+*
+* ## Minimum Scale Clamping
+*
+* All scale factors are clamped to a minimum of 0.01 to prevent:
+* - Shape inversion (negative scale flipping the shape inside-out)
+* - Shape collapse (scale of 0 making the shape a point/line)
+*/
+var ScaleModeWithFreeTransform = class extends ScaleMode {
+	/**
+	* Override handleDragging to support non-uniform scaling.
+	* When lockScaling is false (default), applies separate X/Y scale factors.
+	* When lockScaling is true, applies uniform scaling (same factor for X and Y).
+	*
+	* Note: We don't use parent's handleDragging for uniform scaling because it
+	* calculates scale factors in screen coordinates which distorts rotated shapes.
+	* Instead, we calculate our own uniform scale factor based on distance ratios.
+	*/
+	handleDragging(event, props) {
+		const self = this;
+		if (!self._isScaling) return;
+		props.onUpdateCursor(self._cursor);
+		const scaleContext = this.getScaleContext(event, self);
+		if (!scaleContext) return;
+		const lockScaling = props.modeConfig?.lockScaling ?? false;
+		const { origin, scaleFactors, geometry } = scaleContext;
+		const finalScaleX = lockScaling ? this.calculateUniformScaleFactor(event, origin) : scaleFactors.scaleX;
+		const finalScaleY = lockScaling ? this.calculateUniformScaleFactor(event, origin) : scaleFactors.scaleY;
+		const scaledFeatures = this.applyNonUniformScale(geometry, finalScaleX, finalScaleY, origin);
+		const updatedData = self._getUpdatedData(props, scaledFeatures);
+		props.onEdit({
+			updatedData,
+			editType: "scaling",
+			editContext: { featureIndexes: props.selectedIndexes }
+		});
+		event.cancelPan();
+	}
+	/**
+	* Override handleStopDragging to emit the final scaled geometry.
+	* Uses the same uniform/non-uniform scaling logic as handleDragging.
+	*/
+	handleStopDragging(event, props) {
+		const self = this;
+		if (self._isScaling) {
+			this.emitFinalScaledGeometry(event, props, self);
+			this.resetScaleState(props, self);
+		}
+	}
+	/**
+	* Get the scale context (origin, scale factors, geometry) for the current drag.
+	* Returns null if required data is not available.
+	*/
+	getScaleContext(event, self) {
+		if (!self._selectedEditHandle) return null;
+		const oppositeHandle = self._getOppositeScaleHandle(self._selectedEditHandle);
+		if (!oppositeHandle) return null;
+		const geometry = self._geometryBeingScaled;
+		if (!geometry) return null;
+		const origin = oppositeHandle.geometry.coordinates;
+		return {
+			origin,
+			scaleFactors: this.calculateScaleFactors(event, origin),
+			geometry
+		};
+	}
+	/**
+	* Calculate separate X and Y scale factors based on cursor movement.
+	*
+	* ## Math Explanation
+	*
+	* For each axis, we compute: `scale = currentDelta / startDelta`
+	*
+	* Where:
+	* - `startDelta` = distance from origin to where drag started (the handle position)
+	* - `currentDelta` = distance from origin to current cursor position
+	*
+	* Example: If the handle started 100px from origin and cursor is now 150px from origin,
+	* scale = 150/100 = 1.5 (shape grows to 150% of original size along that axis).
+	*
+	* ## Edge Cases
+	* - If `startDelta` is near zero (handle very close to origin), we return scale=1
+	*   to avoid division by zero and prevent erratic behavior
+	* - Negative scale values are clamped to 0.01 minimum to prevent shape inversion
+	*/
+	calculateScaleFactors(event, origin) {
+		const startDragPoint = event.pointerDownMapCoords;
+		const currentPoint = event.mapCoords;
+		const startDeltaX = (startDragPoint[0] ?? 0) - (origin[0] ?? 0);
+		const startDeltaY = (startDragPoint[1] ?? 0) - (origin[1] ?? 0);
+		const currentDeltaX = (currentPoint[0] ?? 0) - (origin[0] ?? 0);
+		const currentDeltaY = (currentPoint[1] ?? 0) - (origin[1] ?? 0);
+		const epsilon = 1e-7;
+		const minScale = .01;
+		const rawScaleX = Math.abs(startDeltaX) > epsilon ? currentDeltaX / startDeltaX : 1;
+		const rawScaleY = Math.abs(startDeltaY) > epsilon ? currentDeltaY / startDeltaY : 1;
+		return {
+			scaleX: Math.max(rawScaleX, minScale),
+			scaleY: Math.max(rawScaleY, minScale)
+		};
+	}
+	/**
+	* Calculate a uniform scale factor for aspect-ratio-preserving scaling.
+	*
+	* ## Why Use Projection Instead of Simple Distance Ratio?
+	*
+	* A naive approach would be: `scale = distance(origin, cursor) / distance(origin, start)`
+	*
+	* But this fails for diagonal movements - if you drag a corner handle and move
+	* perpendicular to the diagonal, the simple distance changes even though you
+	* don't want the shape to scale.
+	*
+	* ## Vector Projection Math
+	*
+	* Instead, we project the cursor position onto the line defined by
+	* (origin → start drag point). This way, only movement along the original
+	* drag direction affects the scale.
+	*
+	* ```
+	*   Origin          Start (drag handle)
+	*   ●──────────────────●
+	*                       \
+	*                        \  Cursor moved diagonally
+	*                         ●
+	*                        /
+	*                       / Projected point (what we measure from)
+	*   ●──────────────────●
+	*   Origin          Projection
+	* ```
+	*
+	* The projection formula uses the dot product:
+	* ```
+	* projectedDist = (current · start) / |start|
+	* scale = projectedDist / |start|
+	* ```
+	*
+	* This equals: `scale = (current · start) / |start|²`
+	*/
+	calculateUniformScaleFactor(event, origin) {
+		const startDragPoint = event.pointerDownMapCoords;
+		const currentPoint = event.mapCoords;
+		const startDeltaX = (startDragPoint[0] ?? 0) - (origin[0] ?? 0);
+		const startDeltaY = (startDragPoint[1] ?? 0) - (origin[1] ?? 0);
+		const currentDeltaX = (currentPoint[0] ?? 0) - (origin[0] ?? 0);
+		const currentDeltaY = (currentPoint[1] ?? 0) - (origin[1] ?? 0);
+		const startDist = Math.sqrt(startDeltaX ** 2 + startDeltaY ** 2);
+		if (startDist < 1e-7) return 1;
+		const projectedDist = (currentDeltaX * startDeltaX + currentDeltaY * startDeltaY) / startDist;
+		const minScale = .01;
+		const rawScale = projectedDist / startDist;
+		return Math.max(rawScale, minScale);
+	}
+	/**
+	* Emit the final scaled geometry when dragging stops.
+	*/
+	emitFinalScaledGeometry(event, props, self) {
+		const scaleContext = this.getScaleContext(event, self);
+		if (!scaleContext) return;
+		const lockScaling = props.modeConfig?.lockScaling ?? false;
+		const { origin, scaleFactors, geometry } = scaleContext;
+		const finalScaleX = lockScaling ? this.calculateUniformScaleFactor(event, origin) : scaleFactors.scaleX;
+		const finalScaleY = lockScaling ? this.calculateUniformScaleFactor(event, origin) : scaleFactors.scaleY;
+		const scaledFeatures = this.applyNonUniformScale(geometry, finalScaleX, finalScaleY, origin);
+		const updatedData = self._getUpdatedData(props, scaledFeatures);
+		props.onEdit({
+			updatedData,
+			editType: "scaled",
+			editContext: { featureIndexes: props.selectedIndexes }
+		});
+	}
+	/**
+	* Reset the scale state after dragging stops.
+	*/
+	resetScaleState(props, self) {
+		props.onUpdateCursor(null);
+		self._geometryBeingScaled = null;
+		self._selectedEditHandle = null;
+		self._cursor = null;
+		self._isScaling = false;
+	}
+	/**
+	* Apply non-uniform scaling to geometry.
+	* Transforms each coordinate by scaling X and Y independently around the origin.
+	*/
+	applyNonUniformScale(geometry, scaleX, scaleY, origin) {
+		return {
+			type: "FeatureCollection",
+			features: geometry.features.map((feature) => {
+				const scaledGeometry = this.scaleGeometry(feature.geometry, scaleX, scaleY, origin);
+				return {
+					...feature,
+					geometry: scaledGeometry
+				};
+			})
+		};
+	}
+	/**
+	* Scale a geometry's coordinates non-uniformly around an origin point.
+	*
+	* ## Coordinate Transformation
+	*
+	* Each coordinate is transformed using: `new = origin + (old - origin) × scale`
+	*
+	* This is equivalent to:
+	* 1. Translate so origin is at (0,0): `temp = old - origin`
+	* 2. Scale: `temp = temp × scale`
+	* 3. Translate back: `new = temp + origin`
+	*
+	* The origin (opposite corner from the drag handle) stays fixed while
+	* all other points move proportionally.
+	*/
+	scaleGeometry(geometry, scaleX, scaleY, origin) {
+		const scaleCoord = (coord) => {
+			return [(origin[0] ?? 0) + ((coord[0] ?? 0) - (origin[0] ?? 0)) * scaleX, (origin[1] ?? 0) + ((coord[1] ?? 0) - (origin[1] ?? 0)) * scaleY];
+		};
+		switch (geometry.type) {
+			case "Point": return {
+				...geometry,
+				coordinates: scaleCoord(geometry.coordinates)
+			};
+			case "LineString":
+			case "MultiPoint": return {
+				...geometry,
+				coordinates: geometry.coordinates.map(scaleCoord)
+			};
+			case "Polygon":
+			case "MultiLineString": return {
+				...geometry,
+				coordinates: geometry.coordinates.map((ring) => ring.map(scaleCoord))
+			};
+			case "MultiPolygon": return {
+				...geometry,
+				coordinates: geometry.coordinates.map((polygon) => polygon.map((ring) => ring.map(scaleCoord)))
+			};
+			default: return geometry;
+		}
+	}
+};
+
+//#endregion
+export { ScaleModeWithFreeTransform };
+//# sourceMappingURL=scale-mode-with-free-transform.js.map

package/dist/deckgl/shapes/edit-shape-layer/modes/scale-mode-with-free-transform.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scale-mode-with-free-transform.js","names":["origin: Position"],"sources":["../../../../../src/deckgl/shapes/edit-shape-layer/modes/scale-mode-with-free-transform.ts"],"sourcesContent":["/*\n * Copyright 2026 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport {\n  type DraggingEvent,\n  type FeatureCollection,\n  type ModeProps,\n  ScaleMode,\n  type StopDraggingEvent,\n} from '@deck.gl-community/editable-layers';\nimport type { Position } from 'geojson';\n\ntype ScaleFactors = {\n  scaleX: number;\n  scaleY: number;\n};\n\ntype ScaleContext = {\n  origin: Position;\n  scaleFactors: ScaleFactors;\n  geometry: FeatureCollection;\n};\n\n/**\n * Extends ScaleMode to support non-uniform (free) scaling.\n *\n * ## Features\n * - Default: Free scaling - can stretch/squish in any direction\n * - With modeConfig.lockScaling = true: Uniform scaling (maintains aspect ratio)\n *\n * ## How Non-Uniform Scaling Works\n *\n * Non-uniform scaling applies separate X and Y scale factors based on cursor\n * movement relative to the opposite corner (the \"origin\" or anchor point).\n *\n * ```\n *   Origin (opposite corner)           Drag Handle (start)\n *   ●───────────────────────────────────●\n *   │                                   │\n *   │     startDelta = start - origin   │\n *   │     currentDelta = current - origin\n *   │                                   │\n *   │     scaleX = currentDeltaX / startDeltaX\n *   │     scaleY = currentDeltaY / startDeltaY\n *   │                                   │\n *   ●───────────────────────────────────● Cursor (current)\n * ```\n *\n * Each coordinate is transformed: `newCoord = origin + (oldCoord - origin) × scale`\n *\n * ## Why We Override Parent's Uniform Scaling\n *\n * The parent ScaleMode calculates uniform scale factors in screen coordinates,\n * which can distort rotated shapes. We calculate our own uniform factor using\n * vector projection to ensure the corner follows the cursor's projection onto\n * the original drag line, preserving shape orientation.\n *\n * ## Minimum Scale Clamping\n *\n * All scale factors are clamped to a minimum of 0.01 to prevent:\n * - Shape inversion (negative scale flipping the shape inside-out)\n * - Shape collapse (scale of 0 making the shape a point/line)\n */\nexport class ScaleModeWithFreeTransform extends ScaleMode {\n  /**\n   * Override handleDragging to support non-uniform scaling.\n   * When lockScaling is false (default), applies separate X/Y scale factors.\n   * When lockScaling is true, applies uniform scaling (same factor for X and Y).\n   *\n   * Note: We don't use parent's handleDragging for uniform scaling because it\n   * calculates scale factors in screen coordinates which distorts rotated shapes.\n   * Instead, we calculate our own uniform scale factor based on distance ratios.\n   */\n  override handleDragging(\n    event: DraggingEvent,\n    props: ModeProps<FeatureCollection>,\n  ) {\n    // biome-ignore lint/suspicious/noExplicitAny: Accessing private properties from parent class\n    const self = this as any;\n\n    if (!self._isScaling) {\n      return;\n    }\n\n    props.onUpdateCursor(self._cursor);\n\n    const scaleContext = this.getScaleContext(event, self);\n    if (!scaleContext) {\n      return;\n    }\n\n    const lockScaling = props.modeConfig?.lockScaling ?? false;\n    const { origin, scaleFactors, geometry } = scaleContext;\n\n    // For uniform scaling, use a single scale factor for both axes\n    // Calculate based on distance from origin to preserve aspect ratio\n    const finalScaleX = lockScaling\n      ? this.calculateUniformScaleFactor(event, origin)\n      : scaleFactors.scaleX;\n    const finalScaleY = lockScaling\n      ? this.calculateUniformScaleFactor(event, origin)\n      : scaleFactors.scaleY;\n\n    const scaledFeatures = this.applyNonUniformScale(\n      geometry,\n      finalScaleX,\n      finalScaleY,\n      origin,\n    );\n\n    const updatedData = self._getUpdatedData(props, scaledFeatures);\n\n    props.onEdit({\n      updatedData,\n      editType: 'scaling',\n      editContext: {\n        featureIndexes: props.selectedIndexes,\n      },\n    });\n\n    event.cancelPan();\n  }\n\n  /**\n   * Override handleStopDragging to emit the final scaled geometry.\n   * Uses the same uniform/non-uniform scaling logic as handleDragging.\n   */\n  override handleStopDragging(\n    event: StopDraggingEvent,\n    props: ModeProps<FeatureCollection>,\n  ) {\n    // biome-ignore lint/suspicious/noExplicitAny: Accessing private properties from parent class\n    const self = this as any;\n\n    if (self._isScaling) {\n      this.emitFinalScaledGeometry(event, props, self);\n      this.resetScaleState(props, self);\n    }\n  }\n\n  /**\n   * Get the scale context (origin, scale factors, geometry) for the current drag.\n   * Returns null if required data is not available.\n   */\n  private getScaleContext(\n    event: DraggingEvent | StopDraggingEvent,\n    // biome-ignore lint/suspicious/noExplicitAny: Accessing private properties from parent class\n    self: any,\n  ): ScaleContext | null {\n    if (!self._selectedEditHandle) {\n      return null;\n    }\n\n    const oppositeHandle = self._getOppositeScaleHandle(\n      self._selectedEditHandle,\n    );\n    if (!oppositeHandle) {\n      return null;\n    }\n\n    const geometry = self._geometryBeingScaled;\n    if (!geometry) {\n      return null;\n    }\n\n    const origin: Position = oppositeHandle.geometry.coordinates;\n    const scaleFactors = this.calculateScaleFactors(event, origin);\n\n    return { origin, scaleFactors, geometry };\n  }\n\n  /**\n   * Calculate separate X and Y scale factors based on cursor movement.\n   *\n   * ## Math Explanation\n   *\n   * For each axis, we compute: `scale = currentDelta / startDelta`\n   *\n   * Where:\n   * - `startDelta` = distance from origin to where drag started (the handle position)\n   * - `currentDelta` = distance from origin to current cursor position\n   *\n   * Example: If the handle started 100px from origin and cursor is now 150px from origin,\n   * scale = 150/100 = 1.5 (shape grows to 150% of original size along that axis).\n   *\n   * ## Edge Cases\n   * - If `startDelta` is near zero (handle very close to origin), we return scale=1\n   *   to avoid division by zero and prevent erratic behavior\n   * - Negative scale values are clamped to 0.01 minimum to prevent shape inversion\n   */\n  private calculateScaleFactors(\n    event: DraggingEvent | StopDraggingEvent,\n    origin: Position,\n  ): ScaleFactors {\n    const startDragPoint = event.pointerDownMapCoords;\n    const currentPoint = event.mapCoords;\n\n    // Calculate deltas from the anchor point (origin) to drag positions\n    const startDeltaX = (startDragPoint[0] ?? 0) - (origin[0] ?? 0);\n    const startDeltaY = (startDragPoint[1] ?? 0) - (origin[1] ?? 0);\n    const currentDeltaX = (currentPoint[0] ?? 0) - (origin[0] ?? 0);\n    const currentDeltaY = (currentPoint[1] ?? 0) - (origin[1] ?? 0);\n\n    // Epsilon for near-zero checks to avoid division by zero\n    const epsilon = 0.0000001;\n    // Minimum scale to prevent shape from collapsing or inverting\n    const minScale = 0.01;\n\n    // Scale = ratio of (current distance from origin) / (original distance from origin)\n    // If original distance is near-zero, default to scale=1 (no change)\n    const rawScaleX =\n      Math.abs(startDeltaX) > epsilon ? currentDeltaX / startDeltaX : 1;\n    const rawScaleY =\n      Math.abs(startDeltaY) > epsilon ? currentDeltaY / startDeltaY : 1;\n\n    // Clamp to prevent negative values (which would invert/flip the shape)\n    const scaleX = Math.max(rawScaleX, minScale);\n    const scaleY = Math.max(rawScaleY, minScale);\n\n    return { scaleX, scaleY };\n  }\n\n  /**\n   * Calculate a uniform scale factor for aspect-ratio-preserving scaling.\n   *\n   * ## Why Use Projection Instead of Simple Distance Ratio?\n   *\n   * A naive approach would be: `scale = distance(origin, cursor) / distance(origin, start)`\n   *\n   * But this fails for diagonal movements - if you drag a corner handle and move\n   * perpendicular to the diagonal, the simple distance changes even though you\n   * don't want the shape to scale.\n   *\n   * ## Vector Projection Math\n   *\n   * Instead, we project the cursor position onto the line defined by\n   * (origin → start drag point). This way, only movement along the original\n   * drag direction affects the scale.\n   *\n   * ```\n   *   Origin          Start (drag handle)\n   *   ●──────────────────●\n   *                       \\\n   *                        \\  Cursor moved diagonally\n   *                         ●\n   *                        /\n   *                       / Projected point (what we measure from)\n   *   ●──────────────────●\n   *   Origin          Projection\n   * ```\n   *\n   * The projection formula uses the dot product:\n   * ```\n   * projectedDist = (current · start) / |start|\n   * scale = projectedDist / |start|\n   * ```\n   *\n   * This equals: `scale = (current · start) / |start|²`\n   */\n  private calculateUniformScaleFactor(\n    event: DraggingEvent | StopDraggingEvent,\n    origin: Position,\n  ): number {\n    const startDragPoint = event.pointerDownMapCoords;\n    const currentPoint = event.mapCoords;\n\n    // Vector from origin to start drag point (defines the scaling direction)\n    const startDeltaX = (startDragPoint[0] ?? 0) - (origin[0] ?? 0);\n    const startDeltaY = (startDragPoint[1] ?? 0) - (origin[1] ?? 0);\n\n    // Vector from origin to current cursor position\n    const currentDeltaX = (currentPoint[0] ?? 0) - (origin[0] ?? 0);\n    const currentDeltaY = (currentPoint[1] ?? 0) - (origin[1] ?? 0);\n\n    // Distance from origin to start point (|start|)\n    const startDist = Math.sqrt(startDeltaX ** 2 + startDeltaY ** 2);\n\n    if (startDist < 0.0000001) {\n      return 1;\n    }\n\n    // Dot product: current · start = |current| × |start| × cos(θ)\n    // This gives us the component of 'current' that lies along 'start'\n    const dotProduct =\n      currentDeltaX * startDeltaX + currentDeltaY * startDeltaY;\n\n    // Project current point onto start vector: projectedDist = (current · start) / |start|\n    const projectedDist = dotProduct / startDist;\n\n    // Scale factor = projectedDist / |start| = (current · start) / |start|²\n    // Clamp to minScale to prevent negative values (shape inversion)\n    const minScale = 0.01;\n    const rawScale = projectedDist / startDist;\n    return Math.max(rawScale, minScale);\n  }\n\n  /**\n   * Emit the final scaled geometry when dragging stops.\n   */\n  private emitFinalScaledGeometry(\n    event: StopDraggingEvent,\n    props: ModeProps<FeatureCollection>,\n    // biome-ignore lint/suspicious/noExplicitAny: Accessing private properties from parent class\n    self: any,\n  ) {\n    const scaleContext = this.getScaleContext(event, self);\n    if (!scaleContext) {\n      return;\n    }\n\n    const lockScaling = props.modeConfig?.lockScaling ?? false;\n    const { origin, scaleFactors, geometry } = scaleContext;\n\n    // For uniform scaling, use a single scale factor for both axes\n    const finalScaleX = lockScaling\n      ? this.calculateUniformScaleFactor(event, origin)\n      : scaleFactors.scaleX;\n    const finalScaleY = lockScaling\n      ? this.calculateUniformScaleFactor(event, origin)\n      : scaleFactors.scaleY;\n\n    const scaledFeatures = this.applyNonUniformScale(\n      geometry,\n      finalScaleX,\n      finalScaleY,\n      origin,\n    );\n\n    const updatedData = self._getUpdatedData(props, scaledFeatures);\n\n    props.onEdit({\n      updatedData,\n      editType: 'scaled',\n      editContext: {\n        featureIndexes: props.selectedIndexes,\n      },\n    });\n  }\n\n  /**\n   * Reset the scale state after dragging stops.\n   */\n  private resetScaleState(\n    props: ModeProps<FeatureCollection>,\n    // biome-ignore lint/suspicious/noExplicitAny: Accessing private properties from parent class\n    self: any,\n  ) {\n    props.onUpdateCursor(null);\n    self._geometryBeingScaled = null;\n    self._selectedEditHandle = null;\n    self._cursor = null;\n    self._isScaling = false;\n  }\n\n  /**\n   * Apply non-uniform scaling to geometry.\n   * Transforms each coordinate by scaling X and Y independently around the origin.\n   */\n  private applyNonUniformScale(\n    geometry: FeatureCollection,\n    scaleX: number,\n    scaleY: number,\n    origin: Position,\n  ): FeatureCollection {\n    const scaledFeatures = geometry.features.map((feature) => {\n      const scaledGeometry = this.scaleGeometry(\n        feature.geometry,\n        scaleX,\n        scaleY,\n        origin,\n      );\n      return {\n        ...feature,\n        geometry: scaledGeometry,\n      };\n    });\n\n    return {\n      type: 'FeatureCollection',\n      // biome-ignore lint/suspicious/noExplicitAny: GeoJSON feature type variance\n      features: scaledFeatures as any,\n    };\n  }\n\n  /**\n   * Scale a geometry's coordinates non-uniformly around an origin point.\n   *\n   * ## Coordinate Transformation\n   *\n   * Each coordinate is transformed using: `new = origin + (old - origin) × scale`\n   *\n   * This is equivalent to:\n   * 1. Translate so origin is at (0,0): `temp = old - origin`\n   * 2. Scale: `temp = temp × scale`\n   * 3. Translate back: `new = temp + origin`\n   *\n   * The origin (opposite corner from the drag handle) stays fixed while\n   * all other points move proportionally.\n   */\n  private scaleGeometry(\n    // biome-ignore lint/suspicious/noExplicitAny: GeoJSON geometry types are complex - includes Point, LineString, Polygon, Multi* variants\n    geometry: any,\n    scaleX: number,\n    scaleY: number,\n    origin: Position,\n    // biome-ignore lint/suspicious/noExplicitAny: GeoJSON geometry types are complex - return type varies by input\n  ): any {\n    // Transform a single coordinate around the origin point\n    const scaleCoord = (coord: Position): Position => {\n      return [\n        (origin[0] ?? 0) + ((coord[0] ?? 0) - (origin[0] ?? 0)) * scaleX,\n        (origin[1] ?? 0) + ((coord[1] ?? 0) - (origin[1] ?? 0)) * scaleY,\n      ];\n    };\n\n    switch (geometry.type) {\n      case 'Point':\n        return {\n          ...geometry,\n          coordinates: scaleCoord(geometry.coordinates),\n        };\n      case 'LineString':\n      case 'MultiPoint':\n        return {\n          ...geometry,\n          coordinates: geometry.coordinates.map(scaleCoord),\n        };\n      case 'Polygon':\n      case 'MultiLineString':\n        return {\n          ...geometry,\n          coordinates: geometry.coordinates.map((ring: Position[]) =>\n            ring.map(scaleCoord),\n          ),\n        };\n      case 'MultiPolygon':\n        return {\n          ...geometry,\n          coordinates: geometry.coordinates.map((polygon: Position[][]) =>\n            polygon.map((ring: Position[]) => ring.map(scaleCoord)),\n          ),\n        };\n      default:\n        return geometry;\n    }\n  }\n}\n"],"mappings":"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"}

package/dist/deckgl/shapes/edit-shape-layer/modes/vertex-transform-mode.js

@@ -0,0 +1,121 @@
+/*
+ * Copyright 2025 Hypergiant Galactic Systems Inc. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+
+import { BaseTransformMode } from "./base-transform-mode.js";
+import { RotateModeWithSnap } from "./rotate-mode-with-snap.js";
+import { ScaleModeWithFreeTransform } from "./scale-mode-with-free-transform.js";
+import { ModifyMode, TranslateMode } from "@deck.gl-community/editable-layers";
+import { featureCollection } from "@turf/helpers";
+
+//#region src/deckgl/shapes/edit-shape-layer/modes/vertex-transform-mode.ts
+/**
+* Transform mode for shapes that support vertex editing (polygons and lines).
+*
+* Use this mode for shapes where individual vertices can be dragged to reshape
+* the geometry. This provides the most flexibility for freeform shape editing.
+*
+* This composite mode provides:
+* - **Vertex editing** (ModifyMode): Drag vertices to reshape the geometry
+* - **Translation** (TranslateMode): Drag the shape to move it
+* - **Scaling** (ScaleModeWithFreeTransform): Drag corner handles to resize
+*   - Default: Non-uniform scaling (can stretch/squish)
+*   - With Shift: Uniform scaling (maintains aspect ratio)
+* - **Rotation** (RotateModeWithSnap): Drag top handle to rotate
+*   - Default: Free rotation
+*   - With Shift: Snap to 45° intervals
+*
+* Priority logic:
+* - If hovering over a scale handle, scaling takes priority
+* - If hovering over the rotate handle, rotation takes priority
+* - If hovering over a vertex (edit handle from ModifyMode), vertex editing takes priority
+* - Otherwise, dragging the shape translates it
+*
+* The guides from all modes are combined, showing both vertex handles and transform handles.
+*
+* Note: For shapes like rectangles where vertex editing is filtered out (to preserve
+* rotation), consider using BoundingTransformMode instead.
+*
+* Note: This mode does not show tooltips during editing because arbitrary polygons
+* don't have meaningful dimensions to display. Use BoundingTransformMode for shapes
+* like rectangles and ellipses where dimension tooltips are useful.
+*/
+var VertexTransformMode = class extends BaseTransformMode {
+	modifyMode;
+	translateMode;
+	scaleMode;
+	rotateMode;
+	constructor() {
+		const modifyMode = new ModifyMode();
+		const translateMode = new TranslateMode();
+		const scaleMode = new ScaleModeWithFreeTransform();
+		const rotateMode = new RotateModeWithSnap();
+		super([
+			modifyMode,
+			scaleMode,
+			rotateMode,
+			translateMode
+		]);
+		this.modifyMode = modifyMode;
+		this.translateMode = translateMode;
+		this.scaleMode = scaleMode;
+		this.rotateMode = rotateMode;
+	}
+	getHandleMatchers() {
+		return [
+			{
+				match: (pick) => Boolean(pick.isGuide && pick.object?.properties?.guideType === "editHandle" && pick.object?.properties?.editHandleType === "existing"),
+				mode: this.modifyMode
+			},
+			{
+				match: (pick) => Boolean(pick.isGuide && pick.object?.properties?.editHandleType === "scale"),
+				mode: this.scaleMode,
+				shiftConfig: { configKey: "lockScaling" }
+			},
+			{
+				match: (pick) => Boolean(pick.isGuide && pick.object?.properties?.editHandleType === "rotate"),
+				mode: this.rotateMode,
+				shiftConfig: { configKey: "snapRotation" }
+			}
+		];
+	}
+	getDefaultMode() {
+		return this.translateMode;
+	}
+	/**
+	* Override getGuides to filter duplicate envelope guides and handle rectangles.
+	*
+	* Both ScaleMode and RotateMode render the same bounding box envelope.
+	* We keep scale's envelope and filter rotate's duplicate.
+	* We also hide scale handles while rotating to avoid visual clutter.
+	*
+	* For rectangles, we hide vertex handles because vertex editing would distort
+	* the shape or force axis-alignment. Rectangles should use scale handles only.
+	*/
+	getGuides(props) {
+		const allGuides = super.getGuides(props);
+		const isRectangle = props.data.features[0]?.properties?.shape === "Rectangle";
+		return featureCollection(allGuides.features.filter((guide) => {
+			const properties = guide.properties || {};
+			const editHandleType = properties.editHandleType;
+			const guideType = properties.guideType;
+			const guidesToFilterOut = [properties.mode];
+			if (this.rotateMode.getIsRotating()) guidesToFilterOut.push(editHandleType);
+			if (isRectangle && guideType === "editHandle" && editHandleType === "existing") return false;
+			return !guidesToFilterOut.includes("scale");
+		}));
+	}
+};
+
+//#endregion
+export { VertexTransformMode };
+//# sourceMappingURL=vertex-transform-mode.js.map

package/dist/deckgl/shapes/edit-shape-layer/modes/vertex-transform-mode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"vertex-transform-mode.js","names":["guidesToFilterOut: string[]"],"sources":["../../../../../src/deckgl/shapes/edit-shape-layer/modes/vertex-transform-mode.ts"],"sourcesContent":["/*\n * Copyright 2026 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport {\n  type FeatureCollection,\n  type GeoJsonEditMode,\n  type GuideFeatureCollection,\n  type ModeProps,\n  ModifyMode,\n  TranslateMode,\n} from '@deck.gl-community/editable-layers';\nimport { featureCollection } from '@turf/helpers';\nimport { BaseTransformMode, type HandleMatcher } from './base-transform-mode';\nimport { RotateModeWithSnap } from './rotate-mode-with-snap';\nimport { ScaleModeWithFreeTransform } from './scale-mode-with-free-transform';\n\n/**\n * Transform mode for shapes that support vertex editing (polygons and lines).\n *\n * Use this mode for shapes where individual vertices can be dragged to reshape\n * the geometry. This provides the most flexibility for freeform shape editing.\n *\n * This composite mode provides:\n * - **Vertex editing** (ModifyMode): Drag vertices to reshape the geometry\n * - **Translation** (TranslateMode): Drag the shape to move it\n * - **Scaling** (ScaleModeWithFreeTransform): Drag corner handles to resize\n *   - Default: Non-uniform scaling (can stretch/squish)\n *   - With Shift: Uniform scaling (maintains aspect ratio)\n * - **Rotation** (RotateModeWithSnap): Drag top handle to rotate\n *   - Default: Free rotation\n *   - With Shift: Snap to 45° intervals\n *\n * Priority logic:\n * - If hovering over a scale handle, scaling takes priority\n * - If hovering over the rotate handle, rotation takes priority\n * - If hovering over a vertex (edit handle from ModifyMode), vertex editing takes priority\n * - Otherwise, dragging the shape translates it\n *\n * The guides from all modes are combined, showing both vertex handles and transform handles.\n *\n * Note: For shapes like rectangles where vertex editing is filtered out (to preserve\n * rotation), consider using BoundingTransformMode instead.\n *\n * Note: This mode does not show tooltips during editing because arbitrary polygons\n * don't have meaningful dimensions to display. Use BoundingTransformMode for shapes\n * like rectangles and ellipses where dimension tooltips are useful.\n */\nexport class VertexTransformMode extends BaseTransformMode {\n  private modifyMode: ModifyMode;\n  private translateMode: TranslateMode;\n  private scaleMode: ScaleModeWithFreeTransform;\n  private rotateMode: RotateModeWithSnap;\n\n  constructor() {\n    const modifyMode = new ModifyMode();\n    const translateMode = new TranslateMode();\n    const scaleMode = new ScaleModeWithFreeTransform();\n    const rotateMode = new RotateModeWithSnap();\n\n    // Order matters: first mode to handle the event wins\n    // We put modify first so vertex handles take priority over translate\n    super([modifyMode, scaleMode, rotateMode, translateMode]);\n\n    this.modifyMode = modifyMode;\n    this.translateMode = translateMode;\n    this.scaleMode = scaleMode;\n    this.rotateMode = rotateMode;\n  }\n\n  protected override getHandleMatchers(): HandleMatcher[] {\n    return [\n      {\n        // Vertex handle: existing point on polygon/line\n        match: (pick) =>\n          Boolean(\n            pick.isGuide &&\n              pick.object?.properties?.guideType === 'editHandle' &&\n              pick.object?.properties?.editHandleType === 'existing',\n          ),\n        mode: this.modifyMode,\n        // No shift config - vertex editing doesn't have modifiers\n      },\n      {\n        // Scale handle: corner handles on bounding box\n        match: (pick) =>\n          Boolean(\n            pick.isGuide && pick.object?.properties?.editHandleType === 'scale',\n          ),\n        mode: this.scaleMode,\n        shiftConfig: { configKey: 'lockScaling' },\n      },\n      {\n        // Rotate handle: top handle on bounding box\n        match: (pick) =>\n          Boolean(\n            pick.isGuide &&\n              pick.object?.properties?.editHandleType === 'rotate',\n          ),\n        mode: this.rotateMode,\n        shiftConfig: { configKey: 'snapRotation' },\n      },\n    ];\n  }\n\n  protected override getDefaultMode(): GeoJsonEditMode {\n    return this.translateMode;\n  }\n\n  /**\n   * Override getGuides to filter duplicate envelope guides and handle rectangles.\n   *\n   * Both ScaleMode and RotateMode render the same bounding box envelope.\n   * We keep scale's envelope and filter rotate's duplicate.\n   * We also hide scale handles while rotating to avoid visual clutter.\n   *\n   * For rectangles, we hide vertex handles because vertex editing would distort\n   * the shape or force axis-alignment. Rectangles should use scale handles only.\n   */\n  override getGuides(\n    props: ModeProps<FeatureCollection>,\n  ): GuideFeatureCollection {\n    // Get guides from all modes (base class handles pick filtering)\n    const allGuides = super.getGuides(props);\n\n    // Check if we're editing a rectangle - rectangles have shape: 'Rectangle' property\n    const isRectangle =\n      props.data.features[0]?.properties?.shape === 'Rectangle';\n\n    // biome-ignore lint/suspicious/noExplicitAny: Guide properties vary by mode, safely accessing with optional chaining\n    const filteredGuides = allGuides.features.filter((guide: any) => {\n      const properties = guide.properties || {};\n      const editHandleType = properties.editHandleType;\n      const guideType = properties.guideType;\n      const mode = properties.mode;\n\n      // Both scale and rotate modes have the same enveloping box as a guide - only need one\n      const guidesToFilterOut: string[] = [mode as string];\n\n      // Do not render scaling edit handles if rotating\n      if (this.rotateMode.getIsRotating()) {\n        guidesToFilterOut.push(editHandleType as string);\n      }\n\n      // For rectangles, hide ModifyMode vertex handles (editHandleType: 'existing')\n      // Rectangles should only use scale handles for resizing to preserve rotation\n      // Vertex editing would either distort the shape or force axis-alignment\n      if (\n        isRectangle &&\n        guideType === 'editHandle' &&\n        editHandleType === 'existing'\n      ) {\n        return false;\n      }\n\n      return !guidesToFilterOut.includes('scale');\n    });\n\n    // biome-ignore lint/suspicious/noExplicitAny: turf types mismatch with editable-layers GeoJSON types\n    return featureCollection(filteredGuides as any) as any;\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwDA,IAAa,sBAAb,cAAyC,kBAAkB;CACzD,AAAQ;CACR,AAAQ;CACR,AAAQ;CACR,AAAQ;CAER,cAAc;EACZ,MAAM,aAAa,IAAI,YAAY;EACnC,MAAM,gBAAgB,IAAI,eAAe;EACzC,MAAM,YAAY,IAAI,4BAA4B;EAClD,MAAM,aAAa,IAAI,oBAAoB;AAI3C,QAAM;GAAC;GAAY;GAAW;GAAY;GAAc,CAAC;AAEzD,OAAK,aAAa;AAClB,OAAK,gBAAgB;AACrB,OAAK,YAAY;AACjB,OAAK,aAAa;;CAGpB,AAAmB,oBAAqC;AACtD,SAAO;GACL;IAEE,QAAQ,SACN,QACE,KAAK,WACH,KAAK,QAAQ,YAAY,cAAc,gBACvC,KAAK,QAAQ,YAAY,mBAAmB,WAC/C;IACH,MAAM,KAAK;IAEZ;GACD;IAEE,QAAQ,SACN,QACE,KAAK,WAAW,KAAK,QAAQ,YAAY,mBAAmB,QAC7D;IACH,MAAM,KAAK;IACX,aAAa,EAAE,WAAW,eAAe;IAC1C;GACD;IAEE,QAAQ,SACN,QACE,KAAK,WACH,KAAK,QAAQ,YAAY,mBAAmB,SAC/C;IACH,MAAM,KAAK;IACX,aAAa,EAAE,WAAW,gBAAgB;IAC3C;GACF;;CAGH,AAAmB,iBAAkC;AACnD,SAAO,KAAK;;;;;;;;;;;;CAad,AAAS,UACP,OACwB;EAExB,MAAM,YAAY,MAAM,UAAU,MAAM;EAGxC,MAAM,cACJ,MAAM,KAAK,SAAS,IAAI,YAAY,UAAU;AAgChD,SAAO,kBA7BgB,UAAU,SAAS,QAAQ,UAAe;GAC/D,MAAM,aAAa,MAAM,cAAc,EAAE;GACzC,MAAM,iBAAiB,WAAW;GAClC,MAAM,YAAY,WAAW;GAI7B,MAAMA,oBAA8B,CAHvB,WAAW,KAG4B;AAGpD,OAAI,KAAK,WAAW,eAAe,CACjC,mBAAkB,KAAK,eAAyB;AAMlD,OACE,eACA,cAAc,gBACd,mBAAmB,WAEnB,QAAO;AAGT,UAAO,CAAC,kBAAkB,SAAS,QAAQ;IAC3C,CAG6C"}

package/dist/deckgl/shapes/edit-shape-layer/store.js

@@ -0,0 +1,194 @@
+/*
+ * Copyright 2025 Hypergiant Galactic Systems Inc. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+
+'use client';
+
+import { createMapStore } from "../../../shared/create-map-store.js";
+import { MapEvents } from "../../base-map/events.js";
+import { isCircleShape, isEllipseShape, isPointShape, isRectangleShape } from "../shared/types.js";
+import { releaseModeAndCursor, requestCursorChange, requestModeChange } from "../shared/utils/mode-utils.js";
+import { EditShapeEvents } from "./events.js";
+import { EDIT_CURSOR_MAP, EDIT_SHAPE_LAYER_ID, EDIT_SHAPE_MODE } from "./constants.js";
+import { Broadcast } from "@accelint/bus";
+import { getLogger } from "@accelint/logger";
+
+//#region src/deckgl/shapes/edit-shape-layer/store.ts
+/**
+* Edit Shape Store
+*
+* Manages editing state for shape modification.
+*
+* @example
+* ```tsx
+* import { editStore } from '@accelint/map-toolkit/deckgl/shapes';
+*
+* function EditControls({ mapId }) {
+*   const { state, edit, save, cancel } = editStore.use(mapId);
+*
+*   return (
+*     <div>
+*       <p>Editing: {state.editingShape?.name ?? 'none'}</p>
+*       <button onClick={save}>Save</button>
+*       <button onClick={cancel}>Cancel</button>
+*     </div>
+*   );
+* }
+* ```
+*/
+const logger = getLogger({
+	enabled: process.env.NODE_ENV !== "production" && process.env.NODE_ENV !== "test",
+	level: "warn",
+	prefix: "[EditShapeLayer]",
+	pretty: true
+});
+/**
+* Typed event bus instances
+*/
+const editShapeBus = Broadcast.getInstance();
+const mapEventBus = Broadcast.getInstance();
+/**
+* Default editing state
+*/
+const DEFAULT_EDITING_STATE = {
+	editingShape: null,
+	editMode: "view",
+	featureBeingEdited: null
+};
+/**
+* Determine the appropriate edit mode for a shape type
+*/
+function getEditModeForShape(shape) {
+	if (isPointShape(shape)) return "translate";
+	if (isCircleShape(shape)) return "circle-transform";
+	if (isEllipseShape(shape) || isRectangleShape(shape)) return "bounding-transform";
+	return "vertex-transform";
+}
+/**
+* Start editing a shape
+*/
+function startEditing(mapId, state, shape, options, notify, setState) {
+	if (shape.locked) {
+		logger.warn(`Cannot edit locked shape: "${shape.name}"`);
+		return;
+	}
+	if (state.editingShape) cancelEditingInternal(mapId, state, notify, setState);
+	const editMode = options?.mode ?? getEditModeForShape(shape);
+	setState({
+		editingShape: shape,
+		editMode,
+		featureBeingEdited: shape.feature
+	});
+	requestModeChange(mapId, EDIT_SHAPE_MODE, EDIT_SHAPE_LAYER_ID);
+	const cursor = EDIT_CURSOR_MAP[editMode];
+	requestCursorChange(mapId, cursor, EDIT_SHAPE_LAYER_ID);
+	mapEventBus.emit(MapEvents.disablePan, { id: mapId });
+	editShapeBus.emit(EditShapeEvents.editing, {
+		shape,
+		mapId
+	});
+	notify();
+}
+/**
+* Save editing and create updated shape
+*/
+function saveEditingInternal(mapId, state, notify, setState) {
+	if (!(state.editingShape && state.featureBeingEdited)) return null;
+	const originalShape = state.editingShape;
+	const updatedFeature = state.featureBeingEdited;
+	const updatedShape = {
+		...originalShape,
+		feature: {
+			...updatedFeature,
+			properties: {
+				...originalShape.feature.properties,
+				...updatedFeature.properties
+			}
+		},
+		lastUpdated: Date.now()
+	};
+	setState({
+		editingShape: null,
+		editMode: "view",
+		featureBeingEdited: null
+	});
+	releaseModeAndCursor(mapId, EDIT_SHAPE_LAYER_ID);
+	mapEventBus.emit(MapEvents.enablePan, { id: mapId });
+	editShapeBus.emit(EditShapeEvents.updated, {
+		shape: updatedShape,
+		mapId
+	});
+	notify();
+	return updatedShape;
+}
+/**
+* Cancel the current editing operation
+*/
+function cancelEditingInternal(mapId, state, notify, setState) {
+	if (!state.editingShape) return;
+	const originalShape = state.editingShape;
+	setState({
+		editingShape: null,
+		editMode: "view",
+		featureBeingEdited: null
+	});
+	releaseModeAndCursor(mapId, EDIT_SHAPE_LAYER_ID);
+	mapEventBus.emit(MapEvents.enablePan, { id: mapId });
+	editShapeBus.emit(EditShapeEvents.canceled, {
+		shape: originalShape,
+		mapId
+	});
+	notify();
+}
+/**
+* Edit shape store
+*/
+const editStore = createMapStore({
+	defaultState: { ...DEFAULT_EDITING_STATE },
+	actions: (mapId, { get, set, notify }) => ({
+		edit: (shape, options) => {
+			startEditing(mapId, get(), shape, options, notify, set);
+		},
+		save: () => {
+			saveEditingInternal(mapId, get(), notify, set);
+		},
+		cancel: () => {
+			cancelEditingInternal(mapId, get(), notify, set);
+		}
+	}),
+	onCleanup: (mapId, state) => {
+		if (state.editingShape) {
+			releaseModeAndCursor(mapId, EDIT_SHAPE_LAYER_ID);
+			mapEventBus.emit(MapEvents.enablePan, { id: mapId });
+			editShapeBus.emit(EditShapeEvents.canceled, {
+				shape: state.editingShape,
+				mapId
+			});
+		}
+	}
+});
+/**
+* Update feature from the layer component (called during drag operations)
+*/
+function updateFeatureFromLayer(mapId, feature) {
+	editStore.set(mapId, { featureBeingEdited: feature });
+}
+/**
+* Cancel editing (called by the layer component on ESC)
+*/
+function cancelEditingFromLayer(mapId) {
+	editStore.actions(mapId).cancel();
+}
+
+//#endregion
+export { cancelEditingFromLayer, editStore, updateFeatureFromLayer };
+//# sourceMappingURL=store.js.map