@accelint/map-toolkit 1.2.0 → 1.3.0

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

@@ -22,14 +22,39 @@ import { centroid } from "@turf/turf";
 /**
 * Transform mode for circles combining resize and translate.
 *
+* ## Capabilities
 * This composite mode provides:
 * - **Resize** (ResizeCircleMode): Drag edge to resize from center
 * - **Translation** (TranslateMode): Drag the circle body to move it
 * - **Live tooltip**: Shows diameter and area during resize
 *
-* Priority logic:
-* - If dragging on the edge/handle, resize takes priority
-* - If dragging on the circle body, translate takes priority
+* ## Handle Priority Logic
+* When drag starts, modes are evaluated in this priority order:
+* 1. If dragging on the edge/handle → resize takes priority
+* 2. Otherwise → dragging the circle body translates it
+*
+* ## Resize Behavior
+* Unlike scale operations in BoundingTransformMode, circle resize maintains
+* the shape's circular geometry by resizing from the center point. The center
+* remains fixed while the radius changes based on cursor distance.
+*
+* @example
+* ```typescript
+* import { CircleTransformMode } from '@accelint/map-toolkit/deckgl/shapes/edit-shape-layer/modes/circle-transform-mode';
+* import { EditableGeoJsonLayer } from '@deck.gl-community/editable-layers';
+*
+* // Used internally by EditShapeLayer for circles
+* const mode = new CircleTransformMode();
+*
+* const layer = new EditableGeoJsonLayer({
+*   mode,
+*   data: circleFeatureCollection,
+*   selectedFeatureIndexes: [0],
+*   onEdit: handleEdit,
+*   modeConfig: { distanceUnits: 'kilometers' },
+*   // ... other props
+* });
+* ```
 */
 var CircleTransformMode = class extends BaseTransformMode {
 	resizeMode;

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

@@ -1 +1 @@
-{"version":3,"file":"circle-transform-mode.js","names":["area"],"sources":["../../../../../src/deckgl/shapes/edit-shape-layer/modes/circle-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 DraggingEvent,\n  type FeatureCollection,\n  type GeoJsonEditMode,\n  type ModeProps,\n  ResizeCircleMode,\n  TranslateMode,\n} from '@deck.gl-community/editable-layers';\nimport { centroid } from '@turf/turf';\nimport {\n  DEFAULT_DISTANCE_UNITS,\n  getDistanceUnitAbbreviation,\n} from '@/shared/units';\nimport { formatCircleTooltip } from '../../shared/constants';\nimport { computeCircleMeasurements } from '../../shared/utils/geometry-measurements';\nimport { BaseTransformMode, type HandleMatcher } from './base-transform-mode';\nimport type { Feature, Polygon } from 'geojson';\n\n/**\n * Transform mode for circles combining resize and translate.\n *\n * This composite mode provides:\n * - **Resize** (ResizeCircleMode): Drag edge to resize from center\n * - **Translation** (TranslateMode): Drag the circle body to move it\n * - **Live tooltip**: Shows diameter and area during resize\n *\n * Priority logic:\n * - If dragging on the edge/handle, resize takes priority\n * - If dragging on the circle body, translate takes priority\n */\nexport class CircleTransformMode extends BaseTransformMode {\n  private resizeMode: ResizeCircleMode;\n  private translateMode: TranslateMode;\n\n  constructor() {\n    const resizeMode = new ResizeCircleMode();\n    const translateMode = new TranslateMode();\n\n    // Order matters: resize first so edge handles take priority\n    super([resizeMode, translateMode]);\n\n    this.resizeMode = resizeMode;\n    this.translateMode = translateMode;\n  }\n\n  protected override getHandleMatchers(): HandleMatcher[] {\n    return [\n      {\n        // Resize handle: intermediate point on circle edge\n        match: (pick) =>\n          Boolean(\n            pick.isGuide &&\n              pick.object?.properties?.guideType === 'editHandle' &&\n              pick.object?.properties?.editHandleType === 'intermediate',\n          ),\n        mode: this.resizeMode,\n        // No shift config - resize doesn't have modifiers\n      },\n    ];\n  }\n\n  protected override getDefaultMode(): GeoJsonEditMode {\n    return this.translateMode;\n  }\n\n  /**\n   * Update the tooltip with circle diameter and area during resize.\n   */\n  protected override onDragging(\n    event: DraggingEvent,\n    props: ModeProps<FeatureCollection>,\n  ): void {\n    // Only show tooltip when resizing\n    if (this.activeDragMode !== this.resizeMode) {\n      return;\n    }\n\n    const { mapCoords } = event;\n    const distanceUnits =\n      props.modeConfig?.distanceUnits ?? DEFAULT_DISTANCE_UNITS;\n\n    // Get the selected feature to calculate radius from its geometry\n    const selectedIndexes = props.selectedIndexes;\n    const selectedIndex = selectedIndexes?.[0];\n    if (selectedIndex === undefined) {\n      this.tooltip = null;\n      return;\n    }\n\n    const feature = props.data.features[selectedIndex] as\n      | Feature<Polygon>\n      | undefined;\n    if (!feature || feature.geometry.type !== 'Polygon') {\n      this.tooltip = null;\n      return;\n    }\n\n    // Calculate center and radius from the polygon geometry\n    const coordinates = feature.geometry.coordinates[0];\n    if (!coordinates || coordinates.length < 3) {\n      this.tooltip = null;\n      return;\n    }\n\n    const centerFeature = centroid(feature);\n    const center = centerFeature.geometry.coordinates as [number, number];\n    const firstPoint = coordinates[0] as [number, number];\n    const { diameter, area } = computeCircleMeasurements(\n      center,\n      firstPoint,\n      distanceUnits,\n    );\n    const unitAbbrev = getDistanceUnitAbbreviation(distanceUnits);\n\n    // Position tooltip at cursor - offset is applied via getPixelOffset in sublayer props\n    this.tooltip = {\n      position: mapCoords,\n      text: formatCircleTooltip(diameter, area, unitAbbrev),\n    };\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA0CA,IAAa,sBAAb,cAAyC,kBAAkB;CACzD,AAAQ;CACR,AAAQ;CAER,cAAc;EACZ,MAAM,aAAa,IAAI,kBAAkB;EACzC,MAAM,gBAAgB,IAAI,eAAe;AAGzC,QAAM,CAAC,YAAY,cAAc,CAAC;AAElC,OAAK,aAAa;AAClB,OAAK,gBAAgB;;CAGvB,AAAmB,oBAAqC;AACtD,SAAO,CACL;GAEE,QAAQ,SACN,QACE,KAAK,WACH,KAAK,QAAQ,YAAY,cAAc,gBACvC,KAAK,QAAQ,YAAY,mBAAmB,eAC/C;GACH,MAAM,KAAK;GAEZ,CACF;;CAGH,AAAmB,iBAAkC;AACnD,SAAO,KAAK;;;;;CAMd,AAAmB,WACjB,OACA,OACM;AAEN,MAAI,KAAK,mBAAmB,KAAK,WAC/B;EAGF,MAAM,EAAE,cAAc;EACtB,MAAM,gBACJ,MAAM,YAAY,iBAAiB;EAIrC,MAAM,gBADkB,MAAM,kBACU;AACxC,MAAI,kBAAkB,QAAW;AAC/B,QAAK,UAAU;AACf;;EAGF,MAAM,UAAU,MAAM,KAAK,SAAS;AAGpC,MAAI,CAAC,WAAW,QAAQ,SAAS,SAAS,WAAW;AACnD,QAAK,UAAU;AACf;;EAIF,MAAM,cAAc,QAAQ,SAAS,YAAY;AACjD,MAAI,CAAC,eAAe,YAAY,SAAS,GAAG;AAC1C,QAAK,UAAU;AACf;;EAIF,MAAM,SADgB,SAAS,QAAQ,CACV,SAAS;EACtC,MAAM,aAAa,YAAY;EAC/B,MAAM,EAAE,UAAU,iBAAS,0BACzB,QACA,YACA,cACD;AAID,OAAK,UAAU;GACb,UAAU;GACV,MAAM,oBAAoB,UAAUA,QALnB,4BAA4B,cAAc,CAKN;GACtD"}
+{"version":3,"file":"circle-transform-mode.js","names":["area"],"sources":["../../../../../src/deckgl/shapes/edit-shape-layer/modes/circle-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 DraggingEvent,\n  type FeatureCollection,\n  type GeoJsonEditMode,\n  type ModeProps,\n  ResizeCircleMode,\n  TranslateMode,\n} from '@deck.gl-community/editable-layers';\nimport { centroid } from '@turf/turf';\nimport {\n  DEFAULT_DISTANCE_UNITS,\n  getDistanceUnitAbbreviation,\n} from '@/shared/units';\nimport { formatCircleTooltip } from '../../shared/constants';\nimport { computeCircleMeasurements } from '../../shared/utils/geometry-measurements';\nimport { BaseTransformMode, type HandleMatcher } from './base-transform-mode';\nimport type { Feature, Polygon } from 'geojson';\n\n/**\n * Transform mode for circles combining resize and translate.\n *\n * ## Capabilities\n * This composite mode provides:\n * - **Resize** (ResizeCircleMode): Drag edge to resize from center\n * - **Translation** (TranslateMode): Drag the circle body to move it\n * - **Live tooltip**: Shows diameter and area during resize\n *\n * ## Handle Priority Logic\n * When drag starts, modes are evaluated in this priority order:\n * 1. If dragging on the edge/handle → resize takes priority\n * 2. Otherwise → dragging the circle body translates it\n *\n * ## Resize Behavior\n * Unlike scale operations in BoundingTransformMode, circle resize maintains\n * the shape's circular geometry by resizing from the center point. The center\n * remains fixed while the radius changes based on cursor distance.\n *\n * @example\n * ```typescript\n * import { CircleTransformMode } from '@accelint/map-toolkit/deckgl/shapes/edit-shape-layer/modes/circle-transform-mode';\n * import { EditableGeoJsonLayer } from '@deck.gl-community/editable-layers';\n *\n * // Used internally by EditShapeLayer for circles\n * const mode = new CircleTransformMode();\n *\n * const layer = new EditableGeoJsonLayer({\n *   mode,\n *   data: circleFeatureCollection,\n *   selectedFeatureIndexes: [0],\n *   onEdit: handleEdit,\n *   modeConfig: { distanceUnits: 'kilometers' },\n *   // ... other props\n * });\n * ```\n */\nexport class CircleTransformMode extends BaseTransformMode {\n  private resizeMode: ResizeCircleMode;\n  private translateMode: TranslateMode;\n\n  constructor() {\n    const resizeMode = new ResizeCircleMode();\n    const translateMode = new TranslateMode();\n\n    // Order matters: resize first so edge handles take priority\n    super([resizeMode, translateMode]);\n\n    this.resizeMode = resizeMode;\n    this.translateMode = translateMode;\n  }\n\n  protected override getHandleMatchers(): HandleMatcher[] {\n    return [\n      {\n        // Resize handle: intermediate point on circle edge\n        match: (pick) =>\n          Boolean(\n            pick.isGuide &&\n              pick.object?.properties?.guideType === 'editHandle' &&\n              pick.object?.properties?.editHandleType === 'intermediate',\n          ),\n        mode: this.resizeMode,\n        // No shift config - resize doesn't have modifiers\n      },\n    ];\n  }\n\n  protected override getDefaultMode(): GeoJsonEditMode {\n    return this.translateMode;\n  }\n\n  /**\n   * Update the tooltip with circle diameter and area during resize.\n   */\n  protected override onDragging(\n    event: DraggingEvent,\n    props: ModeProps<FeatureCollection>,\n  ): void {\n    // Only show tooltip when resizing\n    if (this.activeDragMode !== this.resizeMode) {\n      return;\n    }\n\n    const { mapCoords } = event;\n    const distanceUnits =\n      props.modeConfig?.distanceUnits ?? DEFAULT_DISTANCE_UNITS;\n\n    // Get the selected feature to calculate radius from its geometry\n    const selectedIndexes = props.selectedIndexes;\n    const selectedIndex = selectedIndexes?.[0];\n    if (selectedIndex === undefined) {\n      this.tooltip = null;\n      return;\n    }\n\n    const feature = props.data.features[selectedIndex] as\n      | Feature<Polygon>\n      | undefined;\n    if (!feature || feature.geometry.type !== 'Polygon') {\n      this.tooltip = null;\n      return;\n    }\n\n    // Calculate center and radius from the polygon geometry\n    const coordinates = feature.geometry.coordinates[0];\n    if (!coordinates || coordinates.length < 3) {\n      this.tooltip = null;\n      return;\n    }\n\n    const centerFeature = centroid(feature);\n    const center = centerFeature.geometry.coordinates as [number, number];\n    const firstPoint = coordinates[0] as [number, number];\n    const { diameter, area } = computeCircleMeasurements(\n      center,\n      firstPoint,\n      distanceUnits,\n    );\n    const unitAbbrev = getDistanceUnitAbbreviation(distanceUnits);\n\n    // Position tooltip at cursor - offset is applied via getPixelOffset in sublayer props\n    this.tooltip = {\n      position: mapCoords,\n      text: formatCircleTooltip(diameter, area, unitAbbrev),\n    };\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmEA,IAAa,sBAAb,cAAyC,kBAAkB;CACzD,AAAQ;CACR,AAAQ;CAER,cAAc;EACZ,MAAM,aAAa,IAAI,kBAAkB;EACzC,MAAM,gBAAgB,IAAI,eAAe;AAGzC,QAAM,CAAC,YAAY,cAAc,CAAC;AAElC,OAAK,aAAa;AAClB,OAAK,gBAAgB;;CAGvB,AAAmB,oBAAqC;AACtD,SAAO,CACL;GAEE,QAAQ,SACN,QACE,KAAK,WACH,KAAK,QAAQ,YAAY,cAAc,gBACvC,KAAK,QAAQ,YAAY,mBAAmB,eAC/C;GACH,MAAM,KAAK;GAEZ,CACF;;CAGH,AAAmB,iBAAkC;AACnD,SAAO,KAAK;;;;;CAMd,AAAmB,WACjB,OACA,OACM;AAEN,MAAI,KAAK,mBAAmB,KAAK,WAC/B;EAGF,MAAM,EAAE,cAAc;EACtB,MAAM,gBACJ,MAAM,YAAY,iBAAiB;EAIrC,MAAM,gBADkB,MAAM,kBACU;AACxC,MAAI,kBAAkB,QAAW;AAC/B,QAAK,UAAU;AACf;;EAGF,MAAM,UAAU,MAAM,KAAK,SAAS;AAGpC,MAAI,CAAC,WAAW,QAAQ,SAAS,SAAS,WAAW;AACnD,QAAK,UAAU;AACf;;EAIF,MAAM,cAAc,QAAQ,SAAS,YAAY;AACjD,MAAI,CAAC,eAAe,YAAY,SAAS,GAAG;AAC1C,QAAK,UAAU;AACf;;EAIF,MAAM,SADgB,SAAS,QAAQ,CACV,SAAS;EACtC,MAAM,aAAa,YAAY;EAC/B,MAAM,EAAE,UAAU,iBAAS,0BACzB,QACA,YACA,cACD;AAID,OAAK,UAAU;GACb,UAAU;GACV,MAAM,oBAAoB,UAAUA,QALnB,4BAA4B,cAAc,CAKN;GACtD"}

package/dist/deckgl/shapes/edit-shape-layer/modes/index.js

@@ -49,8 +49,32 @@ const EDIT_MODE_INSTANCES = {
 /**
 * Get the cached mode instance for an edit mode.
 *
+* Returns the pre-instantiated edit mode for the specified mode type.
+* Modes are cached at module level to prevent deck.gl assertion failures
+* that occur when creating new mode instances on each render.
+*
+* ## Available Edit Modes
+* - `'bounding-transform'`: For shapes without vertex editing (rectangles, ellipses)
+* - `'vertex-transform'`: For shapes with vertex editing (polygons, lines)
+* - `'circle-transform'`: For circles (resize from edge + translate)
+* - `'translate'`: For points (drag to move)
+*
 * @param mode - The edit mode to get the instance for
 * @returns The cached mode instance
+*
+* @example
+* ```typescript
+* import { getEditModeInstance } from '@accelint/map-toolkit/deckgl/shapes/edit-shape-layer/modes';
+*
+* // Get the bounding transform mode for editing rectangles/ellipses
+* const boundingMode = getEditModeInstance('bounding-transform');
+*
+* // Use with EditableGeoJsonLayer
+* const layer = new EditableGeoJsonLayer({
+*   mode: boundingMode,
+*   // ... other props
+* });
+* ```
 */
 function getEditModeInstance(mode) {
 	return EDIT_MODE_INSTANCES[mode];

package/dist/deckgl/shapes/edit-shape-layer/modes/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","names":[],"sources":["../../../../../src/deckgl/shapes/edit-shape-layer/modes/index.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 { TranslateMode, ViewMode } from '@deck.gl-community/editable-layers';\nimport { BoundingTransformMode } from './bounding-transform-mode';\nimport { CircleTransformMode } from './circle-transform-mode';\nimport { VertexTransformMode } from './vertex-transform-mode';\nimport type { EditMode } from '../types';\n\n/**\n * Cached edit mode instances.\n *\n * CRITICAL: Mode instances must be cached at module level to prevent\n * deck.gl assertion failures. Creating new mode instances on each render\n * causes the EditableGeoJsonLayer to fail with assertion errors.\n *\n * BoundingTransformMode combines ScaleModeWithFreeTransform, RotateMode, and\n * TranslateMode for shapes without vertex editing (ellipses, rectangles),\n * allowing non-uniform scaling plus rotate/translate via bounding box handles.\n * Shows live dimension tooltips during scaling.\n *\n * VertexTransformMode combines ModifyMode with ScaleModeWithFreeTransform,\n * RotateMode, and TranslateMode for shapes that support vertex editing\n * (polygons, lines), allowing vertex manipulation plus scale/rotate/translate.\n *\n * CircleTransformMode combines ResizeCircleMode with TranslateMode\n * for circles, allowing resize from edge plus drag to translate.\n * Shows live diameter/area tooltips during resize.\n *\n * TranslateMode allows dragging to move the shape (used for points).\n */\nconst EDIT_MODE_INSTANCES = {\n  view: new ViewMode(),\n  'bounding-transform': new BoundingTransformMode(),\n  'vertex-transform': new VertexTransformMode(),\n  'circle-transform': new CircleTransformMode(),\n  translate: new TranslateMode(),\n} as const;\n\n/**\n * Get the cached mode instance for an edit mode.\n *\n * @param mode - The edit mode to get the instance for\n * @returns The cached mode instance\n */\nexport function getEditModeInstance(\n  mode: EditMode,\n): (typeof EDIT_MODE_INSTANCES)[EditMode] {\n  return EDIT_MODE_INSTANCES[mode];\n}\n\n/**\n * Get the ViewMode instance (for when not editing).\n *\n * @returns The cached ViewMode instance\n */\nexport function getViewModeInstance(): ViewMode {\n  return EDIT_MODE_INSTANCES.view;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,MAAM,sBAAsB;CAC1B,MAAM,IAAI,UAAU;CACpB,sBAAsB,IAAI,uBAAuB;CACjD,oBAAoB,IAAI,qBAAqB;CAC7C,oBAAoB,IAAI,qBAAqB;CAC7C,WAAW,IAAI,eAAe;CAC/B;;;;;;;AAQD,SAAgB,oBACd,MACwC;AACxC,QAAO,oBAAoB"}
+{"version":3,"file":"index.js","names":[],"sources":["../../../../../src/deckgl/shapes/edit-shape-layer/modes/index.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 { TranslateMode, ViewMode } from '@deck.gl-community/editable-layers';\nimport { BoundingTransformMode } from './bounding-transform-mode';\nimport { CircleTransformMode } from './circle-transform-mode';\nimport { VertexTransformMode } from './vertex-transform-mode';\nimport type { EditMode } from '../types';\n\n/**\n * Cached edit mode instances.\n *\n * CRITICAL: Mode instances must be cached at module level to prevent\n * deck.gl assertion failures. Creating new mode instances on each render\n * causes the EditableGeoJsonLayer to fail with assertion errors.\n *\n * BoundingTransformMode combines ScaleModeWithFreeTransform, RotateMode, and\n * TranslateMode for shapes without vertex editing (ellipses, rectangles),\n * allowing non-uniform scaling plus rotate/translate via bounding box handles.\n * Shows live dimension tooltips during scaling.\n *\n * VertexTransformMode combines ModifyMode with ScaleModeWithFreeTransform,\n * RotateMode, and TranslateMode for shapes that support vertex editing\n * (polygons, lines), allowing vertex manipulation plus scale/rotate/translate.\n *\n * CircleTransformMode combines ResizeCircleMode with TranslateMode\n * for circles, allowing resize from edge plus drag to translate.\n * Shows live diameter/area tooltips during resize.\n *\n * TranslateMode allows dragging to move the shape (used for points).\n */\nconst EDIT_MODE_INSTANCES = {\n  view: new ViewMode(),\n  'bounding-transform': new BoundingTransformMode(),\n  'vertex-transform': new VertexTransformMode(),\n  'circle-transform': new CircleTransformMode(),\n  translate: new TranslateMode(),\n} as const;\n\n/**\n * Get the cached mode instance for an edit mode.\n *\n * Returns the pre-instantiated edit mode for the specified mode type.\n * Modes are cached at module level to prevent deck.gl assertion failures\n * that occur when creating new mode instances on each render.\n *\n * ## Available Edit Modes\n * - `'bounding-transform'`: For shapes without vertex editing (rectangles, ellipses)\n * - `'vertex-transform'`: For shapes with vertex editing (polygons, lines)\n * - `'circle-transform'`: For circles (resize from edge + translate)\n * - `'translate'`: For points (drag to move)\n *\n * @param mode - The edit mode to get the instance for\n * @returns The cached mode instance\n *\n * @example\n * ```typescript\n * import { getEditModeInstance } from '@accelint/map-toolkit/deckgl/shapes/edit-shape-layer/modes';\n *\n * // Get the bounding transform mode for editing rectangles/ellipses\n * const boundingMode = getEditModeInstance('bounding-transform');\n *\n * // Use with EditableGeoJsonLayer\n * const layer = new EditableGeoJsonLayer({\n *   mode: boundingMode,\n *   // ... other props\n * });\n * ```\n */\nexport function getEditModeInstance(\n  mode: EditMode,\n): (typeof EDIT_MODE_INSTANCES)[EditMode] {\n  return EDIT_MODE_INSTANCES[mode];\n}\n\n/**\n * Get the ViewMode instance (for when not editing).\n *\n * Returns the pre-instantiated ViewMode which is the default mode when\n * no editing operation is active. This mode allows viewing and interacting\n * with the map without editing shapes.\n *\n * @returns The cached ViewMode instance\n *\n * @example\n * ```typescript\n * import { getViewModeInstance } from '@accelint/map-toolkit/deckgl/shapes/edit-shape-layer/modes';\n *\n * // Get the view mode (default when not editing)\n * const viewMode = getViewModeInstance();\n *\n * // Use with EditableGeoJsonLayer\n * const layer = new EditableGeoJsonLayer({\n *   mode: viewMode,\n *   // ... other props\n * });\n * ```\n */\nexport function getViewModeInstance(): ViewMode {\n  return EDIT_MODE_INSTANCES.view;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAwCA,MAAM,sBAAsB;CAC1B,MAAM,IAAI,UAAU;CACpB,sBAAsB,IAAI,uBAAuB;CACjD,oBAAoB,IAAI,qBAAqB;CAC7C,oBAAoB,IAAI,qBAAqB;CAC7C,WAAW,IAAI,eAAe;CAC/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCD,SAAgB,oBACd,MACwC;AACxC,QAAO,oBAAoB"}

package/dist/deckgl/shapes/edit-shape-layer/modes/rotate-mode-with-snap.js

@@ -38,11 +38,40 @@ function snapAngle(angle, interval) {
 /**
 * Extends RotateMode to support snapping rotation to 45° intervals.
 *
-* Features:
-* - Default: Free rotation
-* - With modeConfig.snapRotation = true: Snap to 45° intervals (0°, 45°, 90°, etc.)
+* ## Features
+* - **Default**: Free rotation (smooth, continuous angles)
+* - **With Shift**: Snap to 45° intervals (0°, 45°, 90°, 135°, 180°, etc.)
 *
-* This allows precise alignment of shapes to common angles.
+* This allows precise alignment of shapes to common angles, making it easy to
+* create axis-aligned or diagonally-aligned shapes.
+*
+* ## Implementation
+* The snap behavior is controlled by the `modeConfig.snapRotation` property,
+* which is set by BaseTransformMode when the Shift key is held. This class
+* calculates the rotation angle and rounds it to the nearest 45° interval
+* when snapping is enabled.
+*
+* ## Snap Interval
+* The snap interval is fixed at 45° (8 positions around the circle), providing
+* these angles: 0°, 45°, 90°, 135°, 180°, 225°, 270°, 315°.
+*
+* @example
+* ```typescript
+* import { RotateModeWithSnap } from '@accelint/map-toolkit/deckgl/shapes/edit-shape-layer/modes/rotate-mode-with-snap';
+* import { EditableGeoJsonLayer } from '@deck.gl-community/editable-layers';
+*
+* const mode = new RotateModeWithSnap();
+*
+* const layer = new EditableGeoJsonLayer({
+*   mode,
+*   data: featureCollection,
+*   selectedFeatureIndexes: [0],
+*   onEdit: handleEdit,
+*   modeConfig: {
+*     snapRotation: true, // Enable 45° snapping
+*   },
+* });
+* ```
 */
 var RotateModeWithSnap = class extends RotateMode {
 	/**

package/dist/deckgl/shapes/edit-shape-layer/modes/rotate-mode-with-snap.js.map

@@ -1 +1 @@
-{"version":3,"file":"rotate-mode-with-snap.js","names":["rotatedFeatures: FeatureCollection"],"sources":["../../../../../src/deckgl/shapes/edit-shape-layer/modes/rotate-mode-with-snap.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  ImmutableFeatureCollection,\n  type ModeProps,\n  RotateMode,\n  type StopDraggingEvent,\n} from '@deck.gl-community/editable-layers';\nimport { bearing, centroid, transformRotate } from '@turf/turf';\nimport type { Position } from 'geojson';\n\n/** Snap interval in degrees (45° = 8 positions around the circle) */\nconst SNAP_INTERVAL_DEGREES = 45;\n\n/**\n * Calculate the angle between two points relative to a centroid.\n * Uses turfBearing for geographic bearing convention (matches parent RotateMode).\n * Returns angle in degrees.\n *\n * Note: centroid must be a turf Point Feature (not just coordinates) to match\n * the parent RotateMode's behavior exactly.\n */\nfunction getRotationAngle(\n  centroidFeature: ReturnType<typeof centroid>,\n  startPoint: Position,\n  endPoint: Position,\n): number {\n  const bearing1 = bearing(centroidFeature, startPoint);\n  const bearing2 = bearing(centroidFeature, endPoint);\n  return bearing2 - bearing1;\n}\n\n/**\n * Snap an angle to the nearest interval.\n */\nfunction snapAngle(angle: number, interval: number): number {\n  return Math.round(angle / interval) * interval;\n}\n\n/**\n * Extends RotateMode to support snapping rotation to 45° intervals.\n *\n * Features:\n * - Default: Free rotation\n * - With modeConfig.snapRotation = true: Snap to 45° intervals (0°, 45°, 90°, etc.)\n *\n * This allows precise alignment of shapes to common angles.\n */\nexport class RotateModeWithSnap extends RotateMode {\n  /**\n   * Override handleDragging to support snapped rotation.\n   * When snapRotation is true, rotates to nearest 45° interval.\n   * When snapRotation is false, delegates to parent for standard rotation.\n   */\n  override handleDragging(\n    event: DraggingEvent,\n    props: ModeProps<FeatureCollection>,\n  ) {\n    const snapRotation = props.modeConfig?.snapRotation ?? false;\n\n    // If not snapping, use parent's rotation logic\n    if (!snapRotation) {\n      super.handleDragging(event, props);\n      return;\n    }\n\n    // biome-ignore lint/suspicious/noExplicitAny: Accessing private properties from parent class\n    const self = this as any;\n\n    if (!self._isRotating) {\n      return;\n    }\n\n    const rotateAction = this.getRotateActionWithSnap(\n      event.pointerDownMapCoords,\n      event.mapCoords,\n      'rotating',\n      props,\n    );\n\n    if (rotateAction) {\n      props.onEdit(rotateAction);\n    }\n\n    event.cancelPan();\n  }\n\n  /**\n   * Override handleStopDragging to emit the final rotated geometry with snap.\n   * When snapRotation is false, delegates to parent for standard rotation.\n   */\n  override handleStopDragging(\n    event: StopDraggingEvent,\n    props: ModeProps<FeatureCollection>,\n  ) {\n    const snapRotation = props.modeConfig?.snapRotation ?? false;\n\n    // If not snapping, use parent's rotation logic\n    if (!snapRotation) {\n      super.handleStopDragging(event, props);\n      return;\n    }\n\n    // biome-ignore lint/suspicious/noExplicitAny: Accessing private properties from parent class\n    const self = this as any;\n\n    if (self._isRotating) {\n      const rotateAction = this.getRotateActionWithSnap(\n        event.pointerDownMapCoords,\n        event.mapCoords,\n        'rotated',\n        props,\n      );\n\n      if (rotateAction) {\n        props.onEdit(rotateAction);\n      }\n\n      // Reset state\n      self._geometryBeingRotated = null;\n      self._selectedEditHandle = null;\n      self._isRotating = false;\n    }\n  }\n\n  /**\n   * Get a rotate action, optionally snapping to 45° intervals.\n   */\n  private getRotateActionWithSnap(\n    startDragPoint: Position,\n    currentPoint: Position,\n    editType: string,\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._geometryBeingRotated) {\n      return null;\n    }\n\n    const geometry = self._geometryBeingRotated as FeatureCollection;\n    // @ts-expect-error turf types differ from editable-layers types\n    const centerFeature = centroid(geometry);\n\n    // Calculate the rotation angle (pass centroid Feature to match parent RotateMode)\n    let angle = getRotationAngle(centerFeature, startDragPoint, currentPoint);\n\n    // Snap to 45° intervals if enabled\n    const snapRotation = props.modeConfig?.snapRotation ?? false;\n    if (snapRotation) {\n      angle = snapAngle(angle, SNAP_INTERVAL_DEGREES);\n    }\n\n    // Apply the rotation using turf (use centroid Feature as pivot to match parent)\n    // @ts-expect-error turf types differ from editable-layers types\n    const rotatedFeatures: FeatureCollection = transformRotate(\n      // @ts-expect-error turf types differ from editable-layers types\n      geometry,\n      angle,\n      {\n        pivot: centerFeature,\n      },\n    );\n\n    // Build the updated data using ImmutableFeatureCollection (matches parent RotateMode)\n    const selectedIndexes = props.selectedIndexes;\n    let updatedData = new ImmutableFeatureCollection(props.data);\n\n    for (let i = 0; i < selectedIndexes.length; i++) {\n      const selectedIndex = selectedIndexes[i];\n      const movedFeature = rotatedFeatures.features[i];\n      if (selectedIndex !== undefined && movedFeature) {\n        updatedData = updatedData.replaceGeometry(\n          selectedIndex,\n          movedFeature.geometry,\n        );\n      }\n    }\n\n    return {\n      updatedData: updatedData.getObject(),\n      editType,\n      editContext: {\n        featureIndexes: selectedIndexes,\n      },\n    };\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAwBA,MAAM,wBAAwB;;;;;;;;;AAU9B,SAAS,iBACP,iBACA,YACA,UACQ;CACR,MAAM,WAAW,QAAQ,iBAAiB,WAAW;AAErD,QADiB,QAAQ,iBAAiB,SAAS,GACjC;;;;;AAMpB,SAAS,UAAU,OAAe,UAA0B;AAC1D,QAAO,KAAK,MAAM,QAAQ,SAAS,GAAG;;;;;;;;;;;AAYxC,IAAa,qBAAb,cAAwC,WAAW;;;;;;CAMjD,AAAS,eACP,OACA,OACA;AAIA,MAAI,EAHiB,MAAM,YAAY,gBAAgB,QAGpC;AACjB,SAAM,eAAe,OAAO,MAAM;AAClC;;AAMF,MAAI,CAFS,KAEH,YACR;EAGF,MAAM,eAAe,KAAK,wBACxB,MAAM,sBACN,MAAM,WACN,YACA,MACD;AAED,MAAI,aACF,OAAM,OAAO,aAAa;AAG5B,QAAM,WAAW;;;;;;CAOnB,AAAS,mBACP,OACA,OACA;AAIA,MAAI,EAHiB,MAAM,YAAY,gBAAgB,QAGpC;AACjB,SAAM,mBAAmB,OAAO,MAAM;AACtC;;EAIF,MAAM,OAAO;AAEb,MAAI,KAAK,aAAa;GACpB,MAAM,eAAe,KAAK,wBACxB,MAAM,sBACN,MAAM,WACN,WACA,MACD;AAED,OAAI,aACF,OAAM,OAAO,aAAa;AAI5B,QAAK,wBAAwB;AAC7B,QAAK,sBAAsB;AAC3B,QAAK,cAAc;;;;;;CAOvB,AAAQ,wBACN,gBACA,cACA,UACA,OACA;EAEA,MAAM,OAAO;AAEb,MAAI,CAAC,KAAK,sBACR,QAAO;EAGT,MAAM,WAAW,KAAK;EAEtB,MAAM,gBAAgB,SAAS,SAAS;EAGxC,IAAI,QAAQ,iBAAiB,eAAe,gBAAgB,aAAa;AAIzE,MADqB,MAAM,YAAY,gBAAgB,MAErD,SAAQ,UAAU,OAAO,sBAAsB;EAKjD,MAAMA,kBAAqC,gBAEzC,UACA,OACA,EACE,OAAO,eACR,CACF;EAGD,MAAM,kBAAkB,MAAM;EAC9B,IAAI,cAAc,IAAI,2BAA2B,MAAM,KAAK;AAE5D,OAAK,IAAI,IAAI,GAAG,IAAI,gBAAgB,QAAQ,KAAK;GAC/C,MAAM,gBAAgB,gBAAgB;GACtC,MAAM,eAAe,gBAAgB,SAAS;AAC9C,OAAI,kBAAkB,UAAa,aACjC,eAAc,YAAY,gBACxB,eACA,aAAa,SACd;;AAIL,SAAO;GACL,aAAa,YAAY,WAAW;GACpC;GACA,aAAa,EACX,gBAAgB,iBACjB;GACF"}
+{"version":3,"file":"rotate-mode-with-snap.js","names":["rotatedFeatures: FeatureCollection"],"sources":["../../../../../src/deckgl/shapes/edit-shape-layer/modes/rotate-mode-with-snap.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  ImmutableFeatureCollection,\n  type ModeProps,\n  RotateMode,\n  type StopDraggingEvent,\n} from '@deck.gl-community/editable-layers';\nimport { bearing, centroid, transformRotate } from '@turf/turf';\nimport type { Position } from 'geojson';\n\n/** Snap interval in degrees (45° = 8 positions around the circle) */\nconst SNAP_INTERVAL_DEGREES = 45;\n\n/**\n * Calculate the angle between two points relative to a centroid.\n * Uses turfBearing for geographic bearing convention (matches parent RotateMode).\n * Returns angle in degrees.\n *\n * Note: centroid must be a turf Point Feature (not just coordinates) to match\n * the parent RotateMode's behavior exactly.\n */\nfunction getRotationAngle(\n  centroidFeature: ReturnType<typeof centroid>,\n  startPoint: Position,\n  endPoint: Position,\n): number {\n  const bearing1 = bearing(centroidFeature, startPoint);\n  const bearing2 = bearing(centroidFeature, endPoint);\n  return bearing2 - bearing1;\n}\n\n/**\n * Snap an angle to the nearest interval.\n */\nfunction snapAngle(angle: number, interval: number): number {\n  return Math.round(angle / interval) * interval;\n}\n\n/**\n * Extends RotateMode to support snapping rotation to 45° intervals.\n *\n * ## Features\n * - **Default**: Free rotation (smooth, continuous angles)\n * - **With Shift**: Snap to 45° intervals (0°, 45°, 90°, 135°, 180°, etc.)\n *\n * This allows precise alignment of shapes to common angles, making it easy to\n * create axis-aligned or diagonally-aligned shapes.\n *\n * ## Implementation\n * The snap behavior is controlled by the `modeConfig.snapRotation` property,\n * which is set by BaseTransformMode when the Shift key is held. This class\n * calculates the rotation angle and rounds it to the nearest 45° interval\n * when snapping is enabled.\n *\n * ## Snap Interval\n * The snap interval is fixed at 45° (8 positions around the circle), providing\n * these angles: 0°, 45°, 90°, 135°, 180°, 225°, 270°, 315°.\n *\n * @example\n * ```typescript\n * import { RotateModeWithSnap } from '@accelint/map-toolkit/deckgl/shapes/edit-shape-layer/modes/rotate-mode-with-snap';\n * import { EditableGeoJsonLayer } from '@deck.gl-community/editable-layers';\n *\n * const mode = new RotateModeWithSnap();\n *\n * const layer = new EditableGeoJsonLayer({\n *   mode,\n *   data: featureCollection,\n *   selectedFeatureIndexes: [0],\n *   onEdit: handleEdit,\n *   modeConfig: {\n *     snapRotation: true, // Enable 45° snapping\n *   },\n * });\n * ```\n */\nexport class RotateModeWithSnap extends RotateMode {\n  /**\n   * Override handleDragging to support snapped rotation.\n   * When snapRotation is true, rotates to nearest 45° interval.\n   * When snapRotation is false, delegates to parent for standard rotation.\n   */\n  override handleDragging(\n    event: DraggingEvent,\n    props: ModeProps<FeatureCollection>,\n  ) {\n    const snapRotation = props.modeConfig?.snapRotation ?? false;\n\n    // If not snapping, use parent's rotation logic\n    if (!snapRotation) {\n      super.handleDragging(event, props);\n      return;\n    }\n\n    // biome-ignore lint/suspicious/noExplicitAny: Accessing private properties from parent class\n    const self = this as any;\n\n    if (!self._isRotating) {\n      return;\n    }\n\n    const rotateAction = this.getRotateActionWithSnap(\n      event.pointerDownMapCoords,\n      event.mapCoords,\n      'rotating',\n      props,\n    );\n\n    if (rotateAction) {\n      props.onEdit(rotateAction);\n    }\n\n    event.cancelPan();\n  }\n\n  /**\n   * Override handleStopDragging to emit the final rotated geometry with snap.\n   * When snapRotation is false, delegates to parent for standard rotation.\n   */\n  override handleStopDragging(\n    event: StopDraggingEvent,\n    props: ModeProps<FeatureCollection>,\n  ) {\n    const snapRotation = props.modeConfig?.snapRotation ?? false;\n\n    // If not snapping, use parent's rotation logic\n    if (!snapRotation) {\n      super.handleStopDragging(event, props);\n      return;\n    }\n\n    // biome-ignore lint/suspicious/noExplicitAny: Accessing private properties from parent class\n    const self = this as any;\n\n    if (self._isRotating) {\n      const rotateAction = this.getRotateActionWithSnap(\n        event.pointerDownMapCoords,\n        event.mapCoords,\n        'rotated',\n        props,\n      );\n\n      if (rotateAction) {\n        props.onEdit(rotateAction);\n      }\n\n      // Reset state\n      self._geometryBeingRotated = null;\n      self._selectedEditHandle = null;\n      self._isRotating = false;\n    }\n  }\n\n  /**\n   * Get a rotate action, optionally snapping to 45° intervals.\n   */\n  private getRotateActionWithSnap(\n    startDragPoint: Position,\n    currentPoint: Position,\n    editType: string,\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._geometryBeingRotated) {\n      return null;\n    }\n\n    const geometry = self._geometryBeingRotated as FeatureCollection;\n    // @ts-expect-error turf types differ from editable-layers types\n    const centerFeature = centroid(geometry);\n\n    // Calculate the rotation angle (pass centroid Feature to match parent RotateMode)\n    let angle = getRotationAngle(centerFeature, startDragPoint, currentPoint);\n\n    // Snap to 45° intervals if enabled\n    const snapRotation = props.modeConfig?.snapRotation ?? false;\n    if (snapRotation) {\n      angle = snapAngle(angle, SNAP_INTERVAL_DEGREES);\n    }\n\n    // Apply the rotation using turf (use centroid Feature as pivot to match parent)\n    // @ts-expect-error turf types differ from editable-layers types\n    const rotatedFeatures: FeatureCollection = transformRotate(\n      // @ts-expect-error turf types differ from editable-layers types\n      geometry,\n      angle,\n      {\n        pivot: centerFeature,\n      },\n    );\n\n    // Build the updated data using ImmutableFeatureCollection (matches parent RotateMode)\n    const selectedIndexes = props.selectedIndexes;\n    let updatedData = new ImmutableFeatureCollection(props.data);\n\n    for (let i = 0; i < selectedIndexes.length; i++) {\n      const selectedIndex = selectedIndexes[i];\n      const movedFeature = rotatedFeatures.features[i];\n      if (selectedIndex !== undefined && movedFeature) {\n        updatedData = updatedData.replaceGeometry(\n          selectedIndex,\n          movedFeature.geometry,\n        );\n      }\n    }\n\n    return {\n      updatedData: updatedData.getObject(),\n      editType,\n      editContext: {\n        featureIndexes: selectedIndexes,\n      },\n    };\n  }\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AAwBA,MAAM,wBAAwB;;;;;;;;;AAU9B,SAAS,iBACP,iBACA,YACA,UACQ;CACR,MAAM,WAAW,QAAQ,iBAAiB,WAAW;AAErD,QADiB,QAAQ,iBAAiB,SAAS,GACjC;;;;;AAMpB,SAAS,UAAU,OAAe,UAA0B;AAC1D,QAAO,KAAK,MAAM,QAAQ,SAAS,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAyCxC,IAAa,qBAAb,cAAwC,WAAW;;;;;;CAMjD,AAAS,eACP,OACA,OACA;AAIA,MAAI,EAHiB,MAAM,YAAY,gBAAgB,QAGpC;AACjB,SAAM,eAAe,OAAO,MAAM;AAClC;;AAMF,MAAI,CAFS,KAEH,YACR;EAGF,MAAM,eAAe,KAAK,wBACxB,MAAM,sBACN,MAAM,WACN,YACA,MACD;AAED,MAAI,aACF,OAAM,OAAO,aAAa;AAG5B,QAAM,WAAW;;;;;;CAOnB,AAAS,mBACP,OACA,OACA;AAIA,MAAI,EAHiB,MAAM,YAAY,gBAAgB,QAGpC;AACjB,SAAM,mBAAmB,OAAO,MAAM;AACtC;;EAIF,MAAM,OAAO;AAEb,MAAI,KAAK,aAAa;GACpB,MAAM,eAAe,KAAK,wBACxB,MAAM,sBACN,MAAM,WACN,WACA,MACD;AAED,OAAI,aACF,OAAM,OAAO,aAAa;AAI5B,QAAK,wBAAwB;AAC7B,QAAK,sBAAsB;AAC3B,QAAK,cAAc;;;;;;CAOvB,AAAQ,wBACN,gBACA,cACA,UACA,OACA;EAEA,MAAM,OAAO;AAEb,MAAI,CAAC,KAAK,sBACR,QAAO;EAGT,MAAM,WAAW,KAAK;EAEtB,MAAM,gBAAgB,SAAS,SAAS;EAGxC,IAAI,QAAQ,iBAAiB,eAAe,gBAAgB,aAAa;AAIzE,MADqB,MAAM,YAAY,gBAAgB,MAErD,SAAQ,UAAU,OAAO,sBAAsB;EAKjD,MAAMA,kBAAqC,gBAEzC,UACA,OACA,EACE,OAAO,eACR,CACF;EAGD,MAAM,kBAAkB,MAAM;EAC9B,IAAI,cAAc,IAAI,2BAA2B,MAAM,KAAK;AAE5D,OAAK,IAAI,IAAI,GAAG,IAAI,gBAAgB,QAAQ,KAAK;GAC/C,MAAM,gBAAgB,gBAAgB;GACtC,MAAM,eAAe,gBAAgB,SAAS;AAC9C,OAAI,kBAAkB,UAAa,aACjC,eAAc,YAAY,gBACxB,eACA,aAAa,SACd;;AAIL,SAAO;GACL,aAAa,YAAY,WAAW;GACpC;GACA,aAAa,EACX,gBAAgB,iBACjB;GACF"}

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

@@ -18,8 +18,8 @@ import { ScaleMode } from "@deck.gl-community/editable-layers";
 * 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)
+* - **Default**: Free scaling - can stretch/squish in any direction
+* - **With Shift**: Uniform scaling (maintains aspect ratio)
 *
 * ## How Non-Uniform Scaling Works
 *
@@ -53,6 +53,25 @@ import { ScaleMode } from "@deck.gl-community/editable-layers";
 * 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)
+*
+* @example
+* ```typescript
+* import { ScaleModeWithFreeTransform } from '@accelint/map-toolkit/deckgl/shapes/edit-shape-layer/modes/scale-mode-with-free-transform';
+* import { EditableGeoJsonLayer } from '@deck.gl-community/editable-layers';
+*
+* const mode = new ScaleModeWithFreeTransform();
+*
+* const layer = new EditableGeoJsonLayer({
+*   mode,
+*   data: featureCollection,
+*   selectedFeatureIndexes: [0],
+*   onEdit: handleEdit,
+*   modeConfig: {
+*     lockScaling: false, // Default: free scaling (stretch/squish)
+*     // lockScaling: true, // Hold Shift: uniform scaling (maintain aspect ratio)
+*   },
+* });
+* ```
 */
 var ScaleModeWithFreeTransform = class extends ScaleMode {
 	/**

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

@@ -1 +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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"}
+{"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 Shift**: 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 *\n * @example\n * ```typescript\n * import { ScaleModeWithFreeTransform } from '@accelint/map-toolkit/deckgl/shapes/edit-shape-layer/modes/scale-mode-with-free-transform';\n * import { EditableGeoJsonLayer } from '@deck.gl-community/editable-layers';\n *\n * const mode = new ScaleModeWithFreeTransform();\n *\n * const layer = new EditableGeoJsonLayer({\n *   mode,\n *   data: featureCollection,\n *   selectedFeatureIndexes: [0],\n *   onEdit: handleEdit,\n *   modeConfig: {\n *     lockScaling: false, // Default: free scaling (stretch/squish)\n *     // lockScaling: true, // Hold Shift: uniform scaling (maintain aspect ratio)\n *   },\n * });\n * ```\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

@@ -24,6 +24,7 @@ import { featureCollection } from "@turf/helpers";
 * Use this mode for shapes where individual vertices can be dragged to reshape
 * the geometry. This provides the most flexibility for freeform shape editing.
 *
+* ## Capabilities
 * This composite mode provides:
 * - **Vertex editing** (ModifyMode): Drag vertices to reshape the geometry
 * - **Translation** (TranslateMode): Drag the shape to move it
@@ -34,20 +35,43 @@ import { featureCollection } from "@turf/helpers";
 *   - 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
+* ## Handle Priority Logic
+* When drag starts, modes are evaluated in this priority order:
+* 1. If hovering over a vertex (edit handle) → vertex editing takes priority
+* 2. If hovering over a scale handle → scaling takes priority
+* 3. If hovering over the rotate handle → rotation takes priority
+* 4. Otherwise → dragging the shape translates it
 *
-* The guides from all modes are combined, showing both vertex handles and transform handles.
+* ## Visual Behavior
+* The guides from all modes are combined, showing both vertex handles (white circles
+* on existing points) and transform handles (corner/rotation handles on bounding box).
 *
-* 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
+* ## Tooltips
+* This mode does not show live measurement tooltips during editing because arbitrary
+* polygons don't have well-defined dimensions. Use BoundingTransformMode for shapes
 * like rectangles and ellipses where dimension tooltips are useful.
+*
+* ## Rectangle Special Handling
+* For rectangles, vertex handles are hidden to preserve rotation and right angles.
+* Only scale/rotate/translate handles are shown. Consider using BoundingTransformMode
+* directly for rectangles if vertex editing should never be available.
+*
+* @example
+* ```typescript
+* import { VertexTransformMode } from '@accelint/map-toolkit/deckgl/shapes/edit-shape-layer/modes/vertex-transform-mode';
+* import { EditableGeoJsonLayer } from '@deck.gl-community/editable-layers';
+*
+* // Used internally by EditShapeLayer for polygons and lines
+* const mode = new VertexTransformMode();
+*
+* const layer = new EditableGeoJsonLayer({
+*   mode,
+*   data: polygonFeatureCollection,
+*   selectedFeatureIndexes: [0],
+*   onEdit: handleEdit,
+*   // ... other props
+* });
+* ```
 */
 var VertexTransformMode = class extends BaseTransformMode {
 	modifyMode;

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

@@ -1 +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"}
+{"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 * ## Capabilities\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 * ## Handle Priority Logic\n * When drag starts, modes are evaluated in this priority order:\n * 1. If hovering over a vertex (edit handle) → vertex editing takes priority\n * 2. If hovering over a scale handle → scaling takes priority\n * 3. If hovering over the rotate handle → rotation takes priority\n * 4. Otherwise → dragging the shape translates it\n *\n * ## Visual Behavior\n * The guides from all modes are combined, showing both vertex handles (white circles\n * on existing points) and transform handles (corner/rotation handles on bounding box).\n *\n * ## Tooltips\n * This mode does not show live measurement tooltips during editing because arbitrary\n * polygons don't have well-defined dimensions. Use BoundingTransformMode for shapes\n * like rectangles and ellipses where dimension tooltips are useful.\n *\n * ## Rectangle Special Handling\n * For rectangles, vertex handles are hidden to preserve rotation and right angles.\n * Only scale/rotate/translate handles are shown. Consider using BoundingTransformMode\n * directly for rectangles if vertex editing should never be available.\n *\n * @example\n * ```typescript\n * import { VertexTransformMode } from '@accelint/map-toolkit/deckgl/shapes/edit-shape-layer/modes/vertex-transform-mode';\n * import { EditableGeoJsonLayer } from '@deck.gl-community/editable-layers';\n *\n * // Used internally by EditShapeLayer for polygons and lines\n * const mode = new VertexTransformMode();\n *\n * const layer = new EditableGeoJsonLayer({\n *   mode,\n *   data: polygonFeatureCollection,\n *   selectedFeatureIndexes: [0],\n *   onEdit: handleEdit,\n *   // ... other props\n * });\n * ```\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":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgFA,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

@@ -29,7 +29,7 @@ import { getLogger } from "@accelint/logger";
 * Manages editing state for shape modification.
 *
 * @example
-* ```tsx
+* ```typescript
 * import { editStore } from '@accelint/map-toolkit/deckgl/shapes';
 *
 * function EditControls({ mapId }) {

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

@@ -1 +1 @@
-{"version":3,"file":"store.js","names":["DEFAULT_EDITING_STATE: EditingState"],"sources":["../../../../src/deckgl/shapes/edit-shape-layer/store.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\n'use client';\n\n/**\n * Edit Shape Store\n *\n * Manages editing state for shape modification.\n *\n * @example\n * ```tsx\n * import { editStore } from '@accelint/map-toolkit/deckgl/shapes';\n *\n * function EditControls({ mapId }) {\n *   const { state, edit, save, cancel } = editStore.use(mapId);\n *\n *   return (\n *     <div>\n *       <p>Editing: {state.editingShape?.name ?? 'none'}</p>\n *       <button onClick={save}>Save</button>\n *       <button onClick={cancel}>Cancel</button>\n *     </div>\n *   );\n * }\n * ```\n */\n\nimport { Broadcast } from '@accelint/bus';\nimport { getLogger } from '@accelint/logger';\nimport { createMapStore } from '@/shared/create-map-store';\nimport { MapEvents } from '../../base-map/events';\nimport {\n  isCircleShape,\n  isEllipseShape,\n  isPointShape,\n  isRectangleShape,\n} from '../shared/types';\nimport {\n  releaseModeAndCursor,\n  requestCursorChange,\n  requestModeChange,\n} from '../shared/utils/mode-utils';\nimport {\n  EDIT_CURSOR_MAP,\n  EDIT_SHAPE_LAYER_ID,\n  EDIT_SHAPE_MODE,\n} from './constants';\nimport { EditShapeEvents } from './events';\nimport type { UniqueId } from '@accelint/core';\nimport type { Feature } from 'geojson';\nimport type { MapEventType } from '../../base-map/types';\nimport type { Shape } from '../shared/types';\nimport type {\n  EditShapeEvent,\n  ShapeEditCanceledEvent,\n  ShapeEditingEvent,\n  ShapeUpdatedEvent,\n} from './events';\nimport type {\n  EditFunction,\n  EditingState,\n  EditMode,\n  EditShapeOptions,\n} from './types';\n\nconst logger = getLogger({\n  enabled:\n    process.env.NODE_ENV !== 'production' && process.env.NODE_ENV !== 'test',\n  level: 'warn',\n  prefix: '[EditShapeLayer]',\n  pretty: true,\n});\n\n/**\n * Typed event bus instances\n */\nconst editShapeBus = Broadcast.getInstance<EditShapeEvent>();\nconst mapEventBus = Broadcast.getInstance<MapEventType>();\n\n/**\n * Default editing state\n */\nconst DEFAULT_EDITING_STATE: EditingState = {\n  editingShape: null,\n  editMode: 'view',\n  featureBeingEdited: null,\n};\n\n/**\n * Actions for edit shape store\n */\ntype EditShapeActions = {\n  /** Start editing a shape */\n  edit: EditFunction;\n  /** Save the current edits */\n  save: () => void;\n  /** Cancel editing */\n  cancel: () => void;\n};\n\n/**\n * Determine the appropriate edit mode for a shape type\n */\nfunction getEditModeForShape(shape: Shape): EditMode {\n  if (isPointShape(shape)) {\n    return 'translate';\n  }\n  if (isCircleShape(shape)) {\n    return 'circle-transform';\n  }\n  if (isEllipseShape(shape) || isRectangleShape(shape)) {\n    return 'bounding-transform';\n  }\n  return 'vertex-transform';\n}\n\n/**\n * Start editing a shape\n */\nfunction startEditing(\n  mapId: UniqueId,\n  state: EditingState,\n  shape: Shape,\n  options: EditShapeOptions | undefined,\n  notify: () => void,\n  setState: (updates: Partial<EditingState>) => void,\n): void {\n  // Prevent editing locked shapes\n  if (shape.locked) {\n    logger.warn(`Cannot edit locked shape: \"${shape.name}\"`);\n    return;\n  }\n\n  // Already editing - cancel first\n  if (state.editingShape) {\n    cancelEditingInternal(mapId, state, notify, setState);\n  }\n\n  // Determine edit mode (can be overridden via options)\n  const editMode = options?.mode ?? getEditModeForShape(shape);\n\n  // Update state with new object reference\n  setState({\n    editingShape: shape,\n    editMode,\n    featureBeingEdited: shape.feature,\n  });\n\n  // Request map mode and cursor\n  requestModeChange(mapId, EDIT_SHAPE_MODE, EDIT_SHAPE_LAYER_ID);\n  const cursor = EDIT_CURSOR_MAP[editMode];\n  requestCursorChange(mapId, cursor, EDIT_SHAPE_LAYER_ID);\n\n  // Disable map panning during editing\n  mapEventBus.emit(MapEvents.disablePan, { id: mapId });\n\n  // Emit editing started event\n  editShapeBus.emit(EditShapeEvents.editing, {\n    shape,\n    mapId,\n  } as unknown as ShapeEditingEvent['payload']);\n\n  notify();\n}\n\n/**\n * Save editing and create updated shape\n */\nfunction saveEditingInternal(\n  mapId: UniqueId,\n  state: EditingState,\n  notify: () => void,\n  setState: (updates: Partial<EditingState>) => void,\n): Shape | null {\n  if (!(state.editingShape && state.featureBeingEdited)) {\n    return null;\n  }\n\n  const originalShape = state.editingShape;\n  const updatedFeature = state.featureBeingEdited;\n\n  // Create updated shape with new geometry\n  const updatedShape = {\n    ...originalShape,\n    feature: {\n      ...updatedFeature,\n      properties: {\n        ...originalShape.feature.properties,\n        ...updatedFeature.properties,\n      },\n    },\n    lastUpdated: Date.now(),\n  } as Shape;\n\n  // Reset state\n  setState({\n    editingShape: null,\n    editMode: 'view',\n    featureBeingEdited: null,\n  });\n\n  // Return to default mode and cursor\n  releaseModeAndCursor(mapId, EDIT_SHAPE_LAYER_ID);\n\n  // Re-enable map panning\n  mapEventBus.emit(MapEvents.enablePan, { id: mapId });\n\n  // Emit shape updated event\n  editShapeBus.emit(EditShapeEvents.updated, {\n    shape: updatedShape,\n    mapId,\n  } as unknown as ShapeUpdatedEvent['payload']);\n\n  notify();\n\n  return updatedShape;\n}\n\n/**\n * Cancel the current editing operation\n */\nfunction cancelEditingInternal(\n  mapId: UniqueId,\n  state: EditingState,\n  notify: () => void,\n  setState: (updates: Partial<EditingState>) => void,\n): void {\n  if (!state.editingShape) {\n    return; // Nothing to cancel\n  }\n\n  const originalShape = state.editingShape;\n\n  // Reset state\n  setState({\n    editingShape: null,\n    editMode: 'view',\n    featureBeingEdited: null,\n  });\n\n  // Return to default mode and cursor\n  releaseModeAndCursor(mapId, EDIT_SHAPE_LAYER_ID);\n\n  // Re-enable map panning\n  mapEventBus.emit(MapEvents.enablePan, { id: mapId });\n\n  // Emit canceled event\n  editShapeBus.emit(EditShapeEvents.canceled, {\n    shape: originalShape,\n    mapId,\n  } as unknown as ShapeEditCanceledEvent['payload']);\n\n  notify();\n}\n\n/**\n * Edit shape store\n */\nexport const editStore = createMapStore<EditingState, EditShapeActions>({\n  defaultState: { ...DEFAULT_EDITING_STATE },\n\n  actions: (mapId, { get, set, notify }) => ({\n    edit: (shape: Shape, options?: EditShapeOptions) => {\n      startEditing(mapId, get(), shape, options, notify, set);\n    },\n\n    save: () => {\n      saveEditingInternal(mapId, get(), notify, set);\n    },\n\n    cancel: () => {\n      cancelEditingInternal(mapId, get(), notify, set);\n    },\n  }),\n\n  // Note: EditShapeLayer is \"neutral\" regarding mode change authorization.\n  // It doesn't auto-cancel or reject mode changes - those decisions are\n  // left to UI components that can prompt the user.\n\n  onCleanup: (mapId, state) => {\n    // Cancel any active editing before cleanup\n    if (state.editingShape) {\n      // Return to default mode and cursor\n      releaseModeAndCursor(mapId, EDIT_SHAPE_LAYER_ID);\n\n      // Re-enable map panning\n      mapEventBus.emit(MapEvents.enablePan, { id: mapId });\n\n      // Emit canceled event\n      editShapeBus.emit(EditShapeEvents.canceled, {\n        shape: state.editingShape,\n        mapId,\n      } as unknown as ShapeEditCanceledEvent['payload']);\n    }\n  },\n});\n\n// =============================================================================\n// Convenience exports\n// =============================================================================\n\n/**\n * Get the current editing state for a mapId\n * Returns null if no store instance exists\n */\nexport function getEditingState(mapId: UniqueId): EditingState | null {\n  if (!editStore.exists(mapId)) {\n    return null;\n  }\n  return editStore.get(mapId);\n}\n\n/**\n * Hook for editing state\n */\nexport function useEditingState(\n  mapId: UniqueId,\n): { state: EditingState } & EditShapeActions {\n  return editStore.use(mapId);\n}\n\n/**\n * Manually clear editing state for a specific mapId.\n */\nexport function clearEditingState(mapId: UniqueId): void {\n  editStore.clear(mapId);\n}\n\n/**\n * Update feature from the layer component (called during drag operations)\n */\nexport function updateFeatureFromLayer(\n  mapId: UniqueId,\n  feature: Feature,\n): void {\n  editStore.set(mapId, { featureBeingEdited: feature });\n}\n\n/**\n * Cancel editing (called by the layer component on ESC)\n */\nexport function cancelEditingFromLayer(mapId: UniqueId): void {\n  editStore.actions(mapId).cancel();\n}\n"],"mappings":"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"}
+{"version":3,"file":"store.js","names":["DEFAULT_EDITING_STATE: EditingState"],"sources":["../../../../src/deckgl/shapes/edit-shape-layer/store.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\n'use client';\n\n/**\n * Edit Shape Store\n *\n * Manages editing state for shape modification.\n *\n * @example\n * ```typescript\n * import { editStore } from '@accelint/map-toolkit/deckgl/shapes';\n *\n * function EditControls({ mapId }) {\n *   const { state, edit, save, cancel } = editStore.use(mapId);\n *\n *   return (\n *     <div>\n *       <p>Editing: {state.editingShape?.name ?? 'none'}</p>\n *       <button onClick={save}>Save</button>\n *       <button onClick={cancel}>Cancel</button>\n *     </div>\n *   );\n * }\n * ```\n */\n\nimport { Broadcast } from '@accelint/bus';\nimport { getLogger } from '@accelint/logger';\nimport { createMapStore } from '@/shared/create-map-store';\nimport { MapEvents } from '../../base-map/events';\nimport {\n  isCircleShape,\n  isEllipseShape,\n  isPointShape,\n  isRectangleShape,\n} from '../shared/types';\nimport {\n  releaseModeAndCursor,\n  requestCursorChange,\n  requestModeChange,\n} from '../shared/utils/mode-utils';\nimport {\n  EDIT_CURSOR_MAP,\n  EDIT_SHAPE_LAYER_ID,\n  EDIT_SHAPE_MODE,\n} from './constants';\nimport { EditShapeEvents } from './events';\nimport type { UniqueId } from '@accelint/core';\nimport type { Feature } from 'geojson';\nimport type { MapEventType } from '../../base-map/types';\nimport type { Shape } from '../shared/types';\nimport type {\n  EditShapeEvent,\n  ShapeEditCanceledEvent,\n  ShapeEditingEvent,\n  ShapeUpdatedEvent,\n} from './events';\nimport type {\n  EditFunction,\n  EditingState,\n  EditMode,\n  EditShapeOptions,\n} from './types';\n\nconst logger = getLogger({\n  enabled:\n    process.env.NODE_ENV !== 'production' && process.env.NODE_ENV !== 'test',\n  level: 'warn',\n  prefix: '[EditShapeLayer]',\n  pretty: true,\n});\n\n/**\n * Typed event bus instances\n */\nconst editShapeBus = Broadcast.getInstance<EditShapeEvent>();\nconst mapEventBus = Broadcast.getInstance<MapEventType>();\n\n/**\n * Default editing state\n */\nconst DEFAULT_EDITING_STATE: EditingState = {\n  editingShape: null,\n  editMode: 'view',\n  featureBeingEdited: null,\n};\n\n/**\n * Actions for edit shape store\n */\ntype EditShapeActions = {\n  /** Start editing a shape */\n  edit: EditFunction;\n  /** Save the current edits */\n  save: () => void;\n  /** Cancel editing */\n  cancel: () => void;\n};\n\n/**\n * Determine the appropriate edit mode for a shape type\n */\nfunction getEditModeForShape(shape: Shape): EditMode {\n  if (isPointShape(shape)) {\n    return 'translate';\n  }\n  if (isCircleShape(shape)) {\n    return 'circle-transform';\n  }\n  if (isEllipseShape(shape) || isRectangleShape(shape)) {\n    return 'bounding-transform';\n  }\n  return 'vertex-transform';\n}\n\n/**\n * Start editing a shape\n */\nfunction startEditing(\n  mapId: UniqueId,\n  state: EditingState,\n  shape: Shape,\n  options: EditShapeOptions | undefined,\n  notify: () => void,\n  setState: (updates: Partial<EditingState>) => void,\n): void {\n  // Prevent editing locked shapes\n  if (shape.locked) {\n    logger.warn(`Cannot edit locked shape: \"${shape.name}\"`);\n    return;\n  }\n\n  // Already editing - cancel first\n  if (state.editingShape) {\n    cancelEditingInternal(mapId, state, notify, setState);\n  }\n\n  // Determine edit mode (can be overridden via options)\n  const editMode = options?.mode ?? getEditModeForShape(shape);\n\n  // Update state with new object reference\n  setState({\n    editingShape: shape,\n    editMode,\n    featureBeingEdited: shape.feature,\n  });\n\n  // Request map mode and cursor\n  requestModeChange(mapId, EDIT_SHAPE_MODE, EDIT_SHAPE_LAYER_ID);\n  const cursor = EDIT_CURSOR_MAP[editMode];\n  requestCursorChange(mapId, cursor, EDIT_SHAPE_LAYER_ID);\n\n  // Disable map panning during editing\n  mapEventBus.emit(MapEvents.disablePan, { id: mapId });\n\n  // Emit editing started event\n  editShapeBus.emit(EditShapeEvents.editing, {\n    shape,\n    mapId,\n  } as unknown as ShapeEditingEvent['payload']);\n\n  notify();\n}\n\n/**\n * Save editing and create updated shape\n */\nfunction saveEditingInternal(\n  mapId: UniqueId,\n  state: EditingState,\n  notify: () => void,\n  setState: (updates: Partial<EditingState>) => void,\n): Shape | null {\n  if (!(state.editingShape && state.featureBeingEdited)) {\n    return null;\n  }\n\n  const originalShape = state.editingShape;\n  const updatedFeature = state.featureBeingEdited;\n\n  // Create updated shape with new geometry\n  const updatedShape = {\n    ...originalShape,\n    feature: {\n      ...updatedFeature,\n      properties: {\n        ...originalShape.feature.properties,\n        ...updatedFeature.properties,\n      },\n    },\n    lastUpdated: Date.now(),\n  } as Shape;\n\n  // Reset state\n  setState({\n    editingShape: null,\n    editMode: 'view',\n    featureBeingEdited: null,\n  });\n\n  // Return to default mode and cursor\n  releaseModeAndCursor(mapId, EDIT_SHAPE_LAYER_ID);\n\n  // Re-enable map panning\n  mapEventBus.emit(MapEvents.enablePan, { id: mapId });\n\n  // Emit shape updated event\n  editShapeBus.emit(EditShapeEvents.updated, {\n    shape: updatedShape,\n    mapId,\n  } as unknown as ShapeUpdatedEvent['payload']);\n\n  notify();\n\n  return updatedShape;\n}\n\n/**\n * Cancel the current editing operation\n */\nfunction cancelEditingInternal(\n  mapId: UniqueId,\n  state: EditingState,\n  notify: () => void,\n  setState: (updates: Partial<EditingState>) => void,\n): void {\n  if (!state.editingShape) {\n    return; // Nothing to cancel\n  }\n\n  const originalShape = state.editingShape;\n\n  // Reset state\n  setState({\n    editingShape: null,\n    editMode: 'view',\n    featureBeingEdited: null,\n  });\n\n  // Return to default mode and cursor\n  releaseModeAndCursor(mapId, EDIT_SHAPE_LAYER_ID);\n\n  // Re-enable map panning\n  mapEventBus.emit(MapEvents.enablePan, { id: mapId });\n\n  // Emit canceled event\n  editShapeBus.emit(EditShapeEvents.canceled, {\n    shape: originalShape,\n    mapId,\n  } as unknown as ShapeEditCanceledEvent['payload']);\n\n  notify();\n}\n\n/**\n * Edit shape store\n */\nexport const editStore = createMapStore<EditingState, EditShapeActions>({\n  defaultState: { ...DEFAULT_EDITING_STATE },\n\n  actions: (mapId, { get, set, notify }) => ({\n    edit: (shape: Shape, options?: EditShapeOptions) => {\n      startEditing(mapId, get(), shape, options, notify, set);\n    },\n\n    save: () => {\n      saveEditingInternal(mapId, get(), notify, set);\n    },\n\n    cancel: () => {\n      cancelEditingInternal(mapId, get(), notify, set);\n    },\n  }),\n\n  // Note: EditShapeLayer is \"neutral\" regarding mode change authorization.\n  // It doesn't auto-cancel or reject mode changes - those decisions are\n  // left to UI components that can prompt the user.\n\n  onCleanup: (mapId, state) => {\n    // Cancel any active editing before cleanup\n    if (state.editingShape) {\n      // Return to default mode and cursor\n      releaseModeAndCursor(mapId, EDIT_SHAPE_LAYER_ID);\n\n      // Re-enable map panning\n      mapEventBus.emit(MapEvents.enablePan, { id: mapId });\n\n      // Emit canceled event\n      editShapeBus.emit(EditShapeEvents.canceled, {\n        shape: state.editingShape,\n        mapId,\n      } as unknown as ShapeEditCanceledEvent['payload']);\n    }\n  },\n});\n\n// =============================================================================\n// Convenience exports\n// =============================================================================\n\n/**\n * Get the current editing state for a mapId\n * Returns null if no store instance exists\n */\nexport function getEditingState(mapId: UniqueId): EditingState | null {\n  if (!editStore.exists(mapId)) {\n    return null;\n  }\n  return editStore.get(mapId);\n}\n\n/**\n * Hook for editing state\n */\nexport function useEditingState(\n  mapId: UniqueId,\n): { state: EditingState } & EditShapeActions {\n  return editStore.use(mapId);\n}\n\n/**\n * Manually clear editing state for a specific mapId.\n */\nexport function clearEditingState(mapId: UniqueId): void {\n  editStore.clear(mapId);\n}\n\n/**\n * Update feature from the layer component (called during drag operations)\n */\nexport function updateFeatureFromLayer(\n  mapId: UniqueId,\n  feature: Feature,\n): void {\n  editStore.set(mapId, { featureBeingEdited: feature });\n}\n\n/**\n * Cancel editing (called by the layer component on ESC)\n */\nexport function cancelEditingFromLayer(mapId: UniqueId): void {\n  editStore.actions(mapId).cancel();\n}\n"],"mappings":"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"}

package/dist/deckgl/shapes/shared/hooks/use-shift-zoom-disable.js

@@ -29,6 +29,18 @@ import { useEmit } from "@accelint/bus/react";
 *
 * @param mapId - The map instance ID
 * @param isActive - Whether the hook should be active (e.g., when editing/drawing)
+*
+* @example
+* ```typescript
+* function EditShapeLayer({ mapId }) {
+*   const isEditing = editStore.use(mapId).state?.editingShape != null;
+*
+*   // Disable zoom when editing to allow Shift modifiers to work
+*   useShiftZoomDisable(mapId, isEditing);
+*
+*   // ... rest of component
+* }
+* ```
 */
 function useShiftZoomDisable(mapId, isActive) {
 	const emitDisableZoom = useEmit(MapEvents.disableZoom);

package/dist/deckgl/shapes/shared/hooks/use-shift-zoom-disable.js.map

@@ -1 +1 @@
-{"version":3,"file":"use-shift-zoom-disable.js","names":[],"sources":["../../../../../src/deckgl/shapes/shared/hooks/use-shift-zoom-disable.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\n'use client';\n\nimport { useEmit } from '@accelint/bus/react';\nimport { useEffect, useRef } from 'react';\nimport { MapEvents } from '@/deckgl/base-map/events';\nimport type { UniqueId } from '@accelint/core';\nimport type {\n  MapDisableZoomEvent,\n  MapEnableZoomEvent,\n} from '@/deckgl/base-map/types';\n\n/**\n * Hook to disable map zoom while Shift key is held during shape operations.\n *\n * This prevents MapLibre's boxZoom (Shift+drag) from interfering with\n * Shift modifier constraints like:\n * - Shift for uniform scaling during edit\n * - Shift for rotation snap during edit\n * - Shift for square constraint during rectangle drawing\n *\n * @param mapId - The map instance ID\n * @param isActive - Whether the hook should be active (e.g., when editing/drawing)\n */\nexport function useShiftZoomDisable(mapId: UniqueId, isActive: boolean): void {\n  const emitDisableZoom = useEmit<MapDisableZoomEvent>(MapEvents.disableZoom);\n  const emitEnableZoom = useEmit<MapEnableZoomEvent>(MapEvents.enableZoom);\n  const isZoomDisabledRef = useRef(false);\n\n  useEffect(() => {\n    if (!isActive) {\n      return;\n    }\n\n    const disableZoom = () => {\n      if (!isZoomDisabledRef.current) {\n        isZoomDisabledRef.current = true;\n        emitDisableZoom({ id: mapId });\n      }\n    };\n\n    const enableZoom = () => {\n      if (isZoomDisabledRef.current) {\n        isZoomDisabledRef.current = false;\n        emitEnableZoom({ id: mapId });\n      }\n    };\n\n    const handleKeyDown = (event: KeyboardEvent) => {\n      if (event.key === 'Shift') {\n        disableZoom();\n      }\n    };\n\n    const handleKeyUp = (event: KeyboardEvent) => {\n      if (event.key === 'Shift') {\n        enableZoom();\n      }\n    };\n\n    // Also catch Shift state on mousedown to handle edge cases where\n    // keydown might have been missed (e.g., focus issues)\n    const handleMouseDown = (event: MouseEvent) => {\n      if (event.shiftKey) {\n        disableZoom();\n      }\n    };\n\n    // Re-enable zoom if the window loses focus while Shift is held\n    const handleBlur = () => {\n      enableZoom();\n    };\n\n    document.addEventListener('keydown', handleKeyDown);\n    document.addEventListener('keyup', handleKeyUp);\n    document.addEventListener('mousedown', handleMouseDown, { capture: true });\n    window.addEventListener('blur', handleBlur);\n\n    return () => {\n      document.removeEventListener('keydown', handleKeyDown);\n      document.removeEventListener('keyup', handleKeyUp);\n      document.removeEventListener('mousedown', handleMouseDown, {\n        capture: true,\n      });\n      window.removeEventListener('blur', handleBlur);\n\n      // Ensure zoom is re-enabled when unmounting\n      enableZoom();\n    };\n  }, [isActive, mapId, emitDisableZoom, emitEnableZoom]);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAmCA,SAAgB,oBAAoB,OAAiB,UAAyB;CAC5E,MAAM,kBAAkB,QAA6B,UAAU,YAAY;CAC3E,MAAM,iBAAiB,QAA4B,UAAU,WAAW;CACxE,MAAM,oBAAoB,OAAO,MAAM;AAEvC,iBAAgB;AACd,MAAI,CAAC,SACH;EAGF,MAAM,oBAAoB;AACxB,OAAI,CAAC,kBAAkB,SAAS;AAC9B,sBAAkB,UAAU;AAC5B,oBAAgB,EAAE,IAAI,OAAO,CAAC;;;EAIlC,MAAM,mBAAmB;AACvB,OAAI,kBAAkB,SAAS;AAC7B,sBAAkB,UAAU;AAC5B,mBAAe,EAAE,IAAI,OAAO,CAAC;;;EAIjC,MAAM,iBAAiB,UAAyB;AAC9C,OAAI,MAAM,QAAQ,QAChB,cAAa;;EAIjB,MAAM,eAAe,UAAyB;AAC5C,OAAI,MAAM,QAAQ,QAChB,aAAY;;EAMhB,MAAM,mBAAmB,UAAsB;AAC7C,OAAI,MAAM,SACR,cAAa;;EAKjB,MAAM,mBAAmB;AACvB,eAAY;;AAGd,WAAS,iBAAiB,WAAW,cAAc;AACnD,WAAS,iBAAiB,SAAS,YAAY;AAC/C,WAAS,iBAAiB,aAAa,iBAAiB,EAAE,SAAS,MAAM,CAAC;AAC1E,SAAO,iBAAiB,QAAQ,WAAW;AAE3C,eAAa;AACX,YAAS,oBAAoB,WAAW,cAAc;AACtD,YAAS,oBAAoB,SAAS,YAAY;AAClD,YAAS,oBAAoB,aAAa,iBAAiB,EACzD,SAAS,MACV,CAAC;AACF,UAAO,oBAAoB,QAAQ,WAAW;AAG9C,eAAY;;IAEb;EAAC;EAAU;EAAO;EAAiB;EAAe,CAAC"}
+{"version":3,"file":"use-shift-zoom-disable.js","names":[],"sources":["../../../../../src/deckgl/shapes/shared/hooks/use-shift-zoom-disable.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\n'use client';\n\nimport { useEmit } from '@accelint/bus/react';\nimport { useEffect, useRef } from 'react';\nimport { MapEvents } from '@/deckgl/base-map/events';\nimport type { UniqueId } from '@accelint/core';\nimport type {\n  MapDisableZoomEvent,\n  MapEnableZoomEvent,\n} from '@/deckgl/base-map/types';\n\n/**\n * Hook to disable map zoom while Shift key is held during shape operations.\n *\n * This prevents MapLibre's boxZoom (Shift+drag) from interfering with\n * Shift modifier constraints like:\n * - Shift for uniform scaling during edit\n * - Shift for rotation snap during edit\n * - Shift for square constraint during rectangle drawing\n *\n * @param mapId - The map instance ID\n * @param isActive - Whether the hook should be active (e.g., when editing/drawing)\n *\n * @example\n * ```typescript\n * function EditShapeLayer({ mapId }) {\n *   const isEditing = editStore.use(mapId).state?.editingShape != null;\n *\n *   // Disable zoom when editing to allow Shift modifiers to work\n *   useShiftZoomDisable(mapId, isEditing);\n *\n *   // ... rest of component\n * }\n * ```\n */\nexport function useShiftZoomDisable(mapId: UniqueId, isActive: boolean): void {\n  const emitDisableZoom = useEmit<MapDisableZoomEvent>(MapEvents.disableZoom);\n  const emitEnableZoom = useEmit<MapEnableZoomEvent>(MapEvents.enableZoom);\n  const isZoomDisabledRef = useRef(false);\n\n  useEffect(() => {\n    if (!isActive) {\n      return;\n    }\n\n    const disableZoom = () => {\n      if (!isZoomDisabledRef.current) {\n        isZoomDisabledRef.current = true;\n        emitDisableZoom({ id: mapId });\n      }\n    };\n\n    const enableZoom = () => {\n      if (isZoomDisabledRef.current) {\n        isZoomDisabledRef.current = false;\n        emitEnableZoom({ id: mapId });\n      }\n    };\n\n    const handleKeyDown = (event: KeyboardEvent) => {\n      if (event.key === 'Shift') {\n        disableZoom();\n      }\n    };\n\n    const handleKeyUp = (event: KeyboardEvent) => {\n      if (event.key === 'Shift') {\n        enableZoom();\n      }\n    };\n\n    // Also catch Shift state on mousedown to handle edge cases where\n    // keydown might have been missed (e.g., focus issues)\n    const handleMouseDown = (event: MouseEvent) => {\n      if (event.shiftKey) {\n        disableZoom();\n      }\n    };\n\n    // Re-enable zoom if the window loses focus while Shift is held\n    const handleBlur = () => {\n      enableZoom();\n    };\n\n    document.addEventListener('keydown', handleKeyDown);\n    document.addEventListener('keyup', handleKeyUp);\n    document.addEventListener('mousedown', handleMouseDown, { capture: true });\n    window.addEventListener('blur', handleBlur);\n\n    return () => {\n      document.removeEventListener('keydown', handleKeyDown);\n      document.removeEventListener('keyup', handleKeyUp);\n      document.removeEventListener('mousedown', handleMouseDown, {\n        capture: true,\n      });\n      window.removeEventListener('blur', handleBlur);\n\n      // Ensure zoom is re-enabled when unmounting\n      enableZoom();\n    };\n  }, [isActive, mapId, emitDisableZoom, emitEnableZoom]);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA+CA,SAAgB,oBAAoB,OAAiB,UAAyB;CAC5E,MAAM,kBAAkB,QAA6B,UAAU,YAAY;CAC3E,MAAM,iBAAiB,QAA4B,UAAU,WAAW;CACxE,MAAM,oBAAoB,OAAO,MAAM;AAEvC,iBAAgB;AACd,MAAI,CAAC,SACH;EAGF,MAAM,oBAAoB;AACxB,OAAI,CAAC,kBAAkB,SAAS;AAC9B,sBAAkB,UAAU;AAC5B,oBAAgB,EAAE,IAAI,OAAO,CAAC;;;EAIlC,MAAM,mBAAmB;AACvB,OAAI,kBAAkB,SAAS;AAC7B,sBAAkB,UAAU;AAC5B,mBAAe,EAAE,IAAI,OAAO,CAAC;;;EAIjC,MAAM,iBAAiB,UAAyB;AAC9C,OAAI,MAAM,QAAQ,QAChB,cAAa;;EAIjB,MAAM,eAAe,UAAyB;AAC5C,OAAI,MAAM,QAAQ,QAChB,aAAY;;EAMhB,MAAM,mBAAmB,UAAsB;AAC7C,OAAI,MAAM,SACR,cAAa;;EAKjB,MAAM,mBAAmB;AACvB,eAAY;;AAGd,WAAS,iBAAiB,WAAW,cAAc;AACnD,WAAS,iBAAiB,SAAS,YAAY;AAC/C,WAAS,iBAAiB,aAAa,iBAAiB,EAAE,SAAS,MAAM,CAAC;AAC1E,SAAO,iBAAiB,QAAQ,WAAW;AAE3C,eAAa;AACX,YAAS,oBAAoB,WAAW,cAAc;AACtD,YAAS,oBAAoB,SAAS,YAAY;AAClD,YAAS,oBAAoB,aAAa,iBAAiB,EACzD,SAAS,MACV,CAAC;AACF,UAAO,oBAAoB,QAAQ,WAAW;AAG9C,eAAY;;IAEb;EAAC;EAAU;EAAO;EAAiB;EAAe,CAAC"}