@accelint/map-toolkit 0.6.0 → 1.1.0

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

@@ -0,0 +1 @@
+{"version":3,"file":"store.js","names":["DEFAULT_DRAWING_STATE: DrawingState"],"sources":["../../../../src/deckgl/shapes/draw-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 * Draw Shape Store\n *\n * Manages drawing state for shape creation.\n *\n * @example\n * ```tsx\n * import { drawStore } from '@accelint/map-toolkit/deckgl/shapes';\n *\n * function DrawControls({ mapId }) {\n *   const { state, draw, cancel } = drawStore.use(mapId);\n *\n *   return (\n *     <div>\n *       <p>Drawing: {state.activeShapeType ?? 'none'}</p>\n *       <button onClick={() => draw('Polygon')}>Draw Polygon</button>\n *       <button onClick={cancel}>Cancel</button>\n *     </div>\n *   );\n * }\n * ```\n */\n\nimport { Broadcast } from '@accelint/bus';\nimport { MapModeEvents } from '@/map-mode/events';\nimport { createMapStore } from '@/shared/create-map-store';\nimport {\n  releaseModeAndCursor,\n  requestModeAndCursor,\n} from '../shared/utils/mode-utils';\nimport {\n  DRAW_CURSOR_MAP,\n  DRAW_SHAPE_LAYER_ID,\n  DRAW_SHAPE_MODE,\n} from './constants';\nimport { DrawShapeEvents } from './events';\nimport { convertFeatureToShape } from './utils/feature-conversion';\nimport type { UniqueId } from '@accelint/core';\nimport type { Feature } from 'geojson';\nimport type { MapModeEventType } from '@/map-mode/types';\nimport type { Shape, ShapeFeatureType } from '../shared/types';\nimport type { DrawShapeEvent, ShapeDrawnEvent } from './events';\nimport type { DrawFunction, DrawingState, DrawShapeOptions } from './types';\n\n/**\n * Typed event bus instances\n */\nconst drawShapeBus = Broadcast.getInstance<DrawShapeEvent>();\nconst mapModeBus = Broadcast.getInstance<MapModeEventType>();\n\n/**\n * Default drawing state\n */\nconst DEFAULT_DRAWING_STATE: DrawingState = {\n  activeShapeType: null,\n  tentativeFeature: null,\n  styleDefaults: null,\n  circleDefaults: null,\n};\n\n/**\n * Actions for draw shape store\n */\ntype DrawShapeActions = {\n  /** Start drawing a shape of the specified type */\n  draw: DrawFunction;\n  /** Cancel the current drawing operation */\n  cancel: () => void;\n};\n\n/**\n * Start drawing a shape\n */\nfunction startDrawing(\n  mapId: UniqueId,\n  state: DrawingState,\n  shapeType: ShapeFeatureType,\n  options: DrawShapeOptions | undefined,\n  notify: () => void,\n  setState: (updates: Partial<DrawingState>) => void,\n): void {\n  // Already drawing - cancel first\n  if (state.activeShapeType) {\n    cancelDrawingInternal(mapId, state, notify, setState);\n  }\n\n  // Update state with new object reference\n  setState({\n    activeShapeType: shapeType,\n    tentativeFeature: null,\n    styleDefaults: options?.styleDefaults ?? null,\n    circleDefaults: options?.circleDefaults ?? null,\n  });\n\n  // Request map mode and cursor using shared utilities\n  const cursor = DRAW_CURSOR_MAP[shapeType];\n  requestModeAndCursor(mapId, DRAW_SHAPE_MODE, cursor, DRAW_SHAPE_LAYER_ID);\n\n  // Emit drawing started event\n  drawShapeBus.emit(DrawShapeEvents.drawing, {\n    shapeType,\n    mapId,\n  });\n\n  notify();\n}\n\n/**\n * Complete drawing and create a shape\n */\nfunction completeDrawingInternal(\n  mapId: UniqueId,\n  state: DrawingState,\n  feature: Feature,\n  notify: () => void,\n  setState: (updates: Partial<DrawingState>) => void,\n): Shape {\n  if (!state.activeShapeType) {\n    throw new Error('Cannot complete drawing - not currently drawing');\n  }\n\n  const shapeType = state.activeShapeType;\n  const styleDefaults = state.styleDefaults;\n\n  // Convert feature to Shape\n  const shape = convertFeatureToShape(feature, shapeType, styleDefaults);\n\n  // Reset state with new object reference\n  setState({\n    activeShapeType: null,\n    tentativeFeature: null,\n    styleDefaults: null,\n    circleDefaults: null,\n  });\n\n  // Release mode and cursor using shared utilities\n  releaseModeAndCursor(mapId, DRAW_SHAPE_LAYER_ID);\n\n  // Emit shape drawn event\n  drawShapeBus.emit(DrawShapeEvents.drawn, {\n    shape,\n    mapId,\n  } as unknown as ShapeDrawnEvent['payload']);\n\n  notify();\n\n  return shape;\n}\n\n/**\n * Cancel the current drawing operation\n */\nfunction cancelDrawingInternal(\n  mapId: UniqueId,\n  state: DrawingState,\n  notify: () => void,\n  setState: (updates: Partial<DrawingState>) => void,\n): void {\n  if (!state.activeShapeType) {\n    return; // Nothing to cancel\n  }\n\n  const shapeType = state.activeShapeType;\n\n  // Reset state with new object reference\n  setState({\n    activeShapeType: null,\n    tentativeFeature: null,\n    styleDefaults: null,\n    circleDefaults: null,\n  });\n\n  // Release mode and cursor using shared utilities\n  releaseModeAndCursor(mapId, DRAW_SHAPE_LAYER_ID);\n\n  // Emit canceled event\n  drawShapeBus.emit(DrawShapeEvents.canceled, {\n    shapeType,\n    mapId,\n  });\n\n  notify();\n}\n\n/**\n * Draw shape store\n */\nexport const drawStore = createMapStore<DrawingState, DrawShapeActions>({\n  defaultState: { ...DEFAULT_DRAWING_STATE },\n\n  actions: (mapId, { get, set, notify }) => ({\n    draw: (shapeType: ShapeFeatureType, options?: DrawShapeOptions) => {\n      startDrawing(mapId, get(), shapeType, options, notify, set);\n    },\n\n    cancel: () => {\n      cancelDrawingInternal(mapId, get(), notify, set);\n    },\n  }),\n\n  bus: (mapId, { get }) => {\n    // Listen for mode authorization requests - REJECT when drawing (protected mode)\n    const unsubAuth = mapModeBus.on(\n      MapModeEvents.changeAuthorization,\n      (event) => {\n        const { authId, id } = event.payload;\n\n        // Filter: only handle if targeted at this map\n        if (id !== mapId) {\n          return;\n        }\n\n        // If we're actively drawing, reject the mode change request\n        if (get().activeShapeType) {\n          mapModeBus.emit(MapModeEvents.changeDecision, {\n            authId,\n            approved: false,\n            owner: DRAW_SHAPE_LAYER_ID,\n            reason: 'Drawing in progress - cancel drawing first',\n            id: mapId,\n          });\n        }\n      },\n    );\n\n    return () => {\n      unsubAuth();\n    };\n  },\n\n  onCleanup: (mapId, state) => {\n    // Cancel any active drawing before cleanup\n    if (state.activeShapeType) {\n      // Release mode and cursor using shared utilities\n      releaseModeAndCursor(mapId, DRAW_SHAPE_LAYER_ID);\n\n      // Emit canceled event\n      drawShapeBus.emit(DrawShapeEvents.canceled, {\n        shapeType: state.activeShapeType,\n        mapId,\n      });\n    }\n  },\n});\n\n// =============================================================================\n// Convenience exports\n// =============================================================================\n\n/**\n * Get the current drawing state for a mapId\n * Returns null if no store instance exists\n */\nexport function getDrawingState(mapId: UniqueId): DrawingState | null {\n  if (!drawStore.exists(mapId)) {\n    return null;\n  }\n  return drawStore.get(mapId);\n}\n\n/**\n * Hook for drawing state\n */\nexport function useDrawingState(\n  mapId: UniqueId,\n): { state: DrawingState } & DrawShapeActions {\n  return drawStore.use(mapId);\n}\n\n/**\n * Manually clear drawing state for a specific mapId.\n */\nexport function clearDrawingState(mapId: UniqueId): void {\n  drawStore.clear(mapId);\n}\n\n/**\n * Complete drawing with a feature (called by the layer component)\n */\nexport function completeDrawingFromLayer(\n  mapId: UniqueId,\n  feature: Feature,\n): Shape {\n  const state = drawStore.get(mapId);\n  return completeDrawingInternal(\n    mapId,\n    state,\n    feature,\n    () => {\n      /* notify handled by set */\n    },\n    (updates) => drawStore.set(mapId, updates),\n  );\n}\n\n/**\n * Cancel drawing (called by the layer component)\n */\nexport function cancelDrawingFromLayer(mapId: UniqueId): void {\n  drawStore.actions(mapId).cancel();\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6DA,MAAM,eAAe,UAAU,aAA6B;AAC5D,MAAM,aAAa,UAAU,aAA+B;;;;AAK5D,MAAMA,wBAAsC;CAC1C,iBAAiB;CACjB,kBAAkB;CAClB,eAAe;CACf,gBAAgB;CACjB;;;;AAeD,SAAS,aACP,OACA,OACA,WACA,SACA,QACA,UACM;AAEN,KAAI,MAAM,gBACR,uBAAsB,OAAO,OAAO,QAAQ,SAAS;AAIvD,UAAS;EACP,iBAAiB;EACjB,kBAAkB;EAClB,eAAe,SAAS,iBAAiB;EACzC,gBAAgB,SAAS,kBAAkB;EAC5C,CAAC;CAGF,MAAM,SAAS,gBAAgB;AAC/B,sBAAqB,OAAO,iBAAiB,QAAQ,oBAAoB;AAGzE,cAAa,KAAK,gBAAgB,SAAS;EACzC;EACA;EACD,CAAC;AAEF,SAAQ;;;;;AAMV,SAAS,wBACP,OACA,OACA,SACA,QACA,UACO;AACP,KAAI,CAAC,MAAM,gBACT,OAAM,IAAI,MAAM,kDAAkD;CAGpE,MAAM,YAAY,MAAM;CACxB,MAAM,gBAAgB,MAAM;CAG5B,MAAM,QAAQ,sBAAsB,SAAS,WAAW,cAAc;AAGtE,UAAS;EACP,iBAAiB;EACjB,kBAAkB;EAClB,eAAe;EACf,gBAAgB;EACjB,CAAC;AAGF,sBAAqB,OAAO,oBAAoB;AAGhD,cAAa,KAAK,gBAAgB,OAAO;EACvC;EACA;EACD,CAA0C;AAE3C,SAAQ;AAER,QAAO;;;;;AAMT,SAAS,sBACP,OACA,OACA,QACA,UACM;AACN,KAAI,CAAC,MAAM,gBACT;CAGF,MAAM,YAAY,MAAM;AAGxB,UAAS;EACP,iBAAiB;EACjB,kBAAkB;EAClB,eAAe;EACf,gBAAgB;EACjB,CAAC;AAGF,sBAAqB,OAAO,oBAAoB;AAGhD,cAAa,KAAK,gBAAgB,UAAU;EAC1C;EACA;EACD,CAAC;AAEF,SAAQ;;;;;AAMV,MAAa,YAAY,eAA+C;CACtE,cAAc,EAAE,GAAG,uBAAuB;CAE1C,UAAU,OAAO,EAAE,KAAK,KAAK,cAAc;EACzC,OAAO,WAA6B,YAA+B;AACjE,gBAAa,OAAO,KAAK,EAAE,WAAW,SAAS,QAAQ,IAAI;;EAG7D,cAAc;AACZ,yBAAsB,OAAO,KAAK,EAAE,QAAQ,IAAI;;EAEnD;CAED,MAAM,OAAO,EAAE,UAAU;EAEvB,MAAM,YAAY,WAAW,GAC3B,cAAc,sBACb,UAAU;GACT,MAAM,EAAE,QAAQ,OAAO,MAAM;AAG7B,OAAI,OAAO,MACT;AAIF,OAAI,KAAK,CAAC,gBACR,YAAW,KAAK,cAAc,gBAAgB;IAC5C;IACA,UAAU;IACV,OAAO;IACP,QAAQ;IACR,IAAI;IACL,CAAC;IAGP;AAED,eAAa;AACX,cAAW;;;CAIf,YAAY,OAAO,UAAU;AAE3B,MAAI,MAAM,iBAAiB;AAEzB,wBAAqB,OAAO,oBAAoB;AAGhD,gBAAa,KAAK,gBAAgB,UAAU;IAC1C,WAAW,MAAM;IACjB;IACD,CAAC;;;CAGP,CAAC;;;;AAoCF,SAAgB,yBACd,OACA,SACO;AAEP,QAAO,wBACL,OAFY,UAAU,IAAI,MAAM,EAIhC,eACM,KAGL,YAAY,UAAU,IAAI,OAAO,QAAQ,CAC3C;;;;;AAMH,SAAgB,uBAAuB,OAAuB;AAC5D,WAAU,QAAQ,MAAM,CAAC,QAAQ"}

package/dist/deckgl/shapes/draw-shape-layer/types.d.ts

@@ -0,0 +1,86 @@
+/*
+ * Copyright 2025 Hypergiant Galactic Systems Inc. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import { DistanceUnitAbbreviation } from "../../../shared/units.js";
+import { CircleProperties, Shape, ShapeFeatureType, StyleProperties } from "../shared/types.js";
+import { UniqueId } from "@accelint/core";
+import { Feature } from "geojson";
+
+//#region src/deckgl/shapes/draw-shape-layer/types.d.ts
+/**
+ * State for the drawing store
+ */
+type DrawingState = {
+  /** Current shape type being drawn, null when not drawing */
+  activeShapeType: ShapeFeatureType | null;
+  /** Tentative feature being drawn (updates in real-time) */
+  tentativeFeature: Feature | null;
+  /** Default style properties to apply to drawn shapes */
+  styleDefaults: Partial<StyleProperties> | null;
+  /** Default circle properties (for Circle shapes) */
+  circleDefaults: Partial<CircleProperties> | null;
+};
+/**
+ * Options for starting a drawing operation
+ */
+type DrawShapeOptions = {
+  /** Default style properties for the drawn shape */
+  styleDefaults?: Partial<StyleProperties>;
+  /** Circle-specific defaults (only used for Circle shapes) */
+  circleDefaults?: Partial<CircleProperties>;
+};
+/**
+ * Options for the useDrawShape hook
+ */
+type UseDrawShapeOptions = {
+  /** Callback when a shape is successfully drawn */
+  onCreate?: (shape: Shape) => void;
+  /** Callback when drawing is canceled */
+  onCancel?: (shapeType: ShapeFeatureType) => void;
+};
+/**
+ * Return type for the useDrawShape hook
+ */
+type UseDrawShapeReturn = {
+  /** Current drawing state (null when not drawing) */
+  drawingState: DrawingState | null;
+  /** Start drawing a shape type with optional defaults */
+  draw: (shapeType: ShapeFeatureType, options?: DrawShapeOptions) => void;
+  /** Cancel the current drawing operation */
+  cancel: () => void;
+  /** Whether currently in drawing mode */
+  isDrawing: boolean;
+  /** The shape type currently being drawn (null if not drawing) */
+  activeShapeType: ShapeFeatureType | null;
+};
+/**
+ * Props for the DrawShapeLayer component
+ */
+type DrawShapeLayerProps = {
+  /** Layer ID (defaults to 'draw-shape-layer') */
+  id?: string;
+  /**
+   * Map instance ID for multi-map isolation.
+   * Optional when used inside a MapProvider (uses context).
+   * Required when used outside a MapProvider.
+   */
+  mapId?: UniqueId;
+  /** Distance unit for tooltip measurements (defaults to 'km') */
+  unit?: DistanceUnitAbbreviation;
+};
+/**
+ * Function type for the draw action
+ */
+type DrawFunction = (shapeType: ShapeFeatureType, options?: DrawShapeOptions) => void;
+//#endregion
+export { DrawFunction, DrawShapeLayerProps, DrawShapeOptions, DrawingState, UseDrawShapeOptions, UseDrawShapeReturn };
+//# sourceMappingURL=types.d.ts.map

package/dist/{viewport/constants.js → deckgl/shapes/draw-shape-layer/types.js}

@@ -11,15 +11,4 @@
  */
 
 
-//#region src/viewport/constants.ts
-const UNIT_MAP = {
-	km: "kilometers",
-	m: "meters",
-	nm: "nauticalmiles",
-	mi: "miles",
-	ft: "feet"
-};
-
-//#endregion
-export { UNIT_MAP };
-//# sourceMappingURL=constants.js.map
+'use client';

package/dist/deckgl/shapes/draw-shape-layer/use-draw-shape.d.ts

@@ -0,0 +1,82 @@
+/*
+ * Copyright 2025 Hypergiant Galactic Systems Inc. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import { UseDrawShapeOptions, UseDrawShapeReturn } from "./types.js";
+import { UniqueId } from "@accelint/core";
+
+//#region src/deckgl/shapes/draw-shape-layer/use-draw-shape.d.ts
+
+/**
+ * Hook to access the shape drawing state and actions.
+ *
+ * This hook uses `useSyncExternalStore` to subscribe to drawing state changes,
+ * providing concurrent-safe state updates. Uses a fan-out pattern where
+ * a single bus listener per map instance notifies N React component subscribers.
+ *
+ * @param mapId - Optional map instance ID. If not provided, will use the ID from `MapContext`.
+ * @param options - Optional callbacks for onCreate and onCancel events
+ * @returns Drawing state, draw function, cancel function, and convenience flags
+ * @throws Error if no `mapId` is provided and hook is used outside of `MapProvider`
+ *
+ * @example
+ * ```tsx
+ * // Inside MapProvider (within BaseMap children) - uses context
+ * function DrawingToolbar() {
+ *   const { draw, cancel, isDrawing, activeShapeType } = useDrawShape(undefined, {
+ *     onCreate: (shape) => {
+ *       console.log('Shape created:', shape);
+ *       setShapes(prev => [...prev, shape]);
+ *     },
+ *     onCancel: (shapeType) => {
+ *       console.log('Drawing canceled:', shapeType);
+ *     },
+ *   });
+ *
+ *   return (
+ *     <div>
+ *       <button onClick={() => draw(ShapeFeatureType.Polygon)}>
+ *         Draw Polygon
+ *       </button>
+ *       <button onClick={() => draw(ShapeFeatureType.Circle)}>
+ *         Draw Circle
+ *       </button>
+ *       {isDrawing && (
+ *         <button onClick={cancel}>
+ *           Cancel ({activeShapeType})
+ *         </button>
+ *       )}
+ *     </div>
+ *   );
+ * }
+ * ```
+ *
+ * @example
+ * ```tsx
+ * // Outside MapProvider - pass mapId directly
+ * function ExternalDrawingControl({ mapId }: { mapId: UniqueId }) {
+ *   const { draw, isDrawing } = useDrawShape(mapId);
+ *
+ *   return (
+ *     <button
+ *       onClick={() => draw(ShapeFeatureType.Point)}
+ *       disabled={isDrawing}
+ *     >
+ *       Add Point
+ *     </button>
+ *   );
+ * }
+ * ```
+ */
+declare function useDrawShape(mapId?: UniqueId, options?: UseDrawShapeOptions): UseDrawShapeReturn;
+//#endregion
+export { useDrawShape };
+//# sourceMappingURL=use-draw-shape.d.ts.map

package/dist/deckgl/shapes/draw-shape-layer/use-draw-shape.js

@@ -0,0 +1,112 @@
+/*
+ * Copyright 2025 Hypergiant Galactic Systems Inc. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+
+'use client';
+
+import { MapContext } from "../../base-map/provider.js";
+import { DrawShapeEvents } from "./events.js";
+import { drawStore } from "./store.js";
+import { useContext, useMemo } from "react";
+import { useBus } from "@accelint/bus/react";
+
+//#region src/deckgl/shapes/draw-shape-layer/use-draw-shape.ts
+/**
+* Hook to access the shape drawing state and actions.
+*
+* This hook uses `useSyncExternalStore` to subscribe to drawing state changes,
+* providing concurrent-safe state updates. Uses a fan-out pattern where
+* a single bus listener per map instance notifies N React component subscribers.
+*
+* @param mapId - Optional map instance ID. If not provided, will use the ID from `MapContext`.
+* @param options - Optional callbacks for onCreate and onCancel events
+* @returns Drawing state, draw function, cancel function, and convenience flags
+* @throws Error if no `mapId` is provided and hook is used outside of `MapProvider`
+*
+* @example
+* ```tsx
+* // Inside MapProvider (within BaseMap children) - uses context
+* function DrawingToolbar() {
+*   const { draw, cancel, isDrawing, activeShapeType } = useDrawShape(undefined, {
+*     onCreate: (shape) => {
+*       console.log('Shape created:', shape);
+*       setShapes(prev => [...prev, shape]);
+*     },
+*     onCancel: (shapeType) => {
+*       console.log('Drawing canceled:', shapeType);
+*     },
+*   });
+*
+*   return (
+*     <div>
+*       <button onClick={() => draw(ShapeFeatureType.Polygon)}>
+*         Draw Polygon
+*       </button>
+*       <button onClick={() => draw(ShapeFeatureType.Circle)}>
+*         Draw Circle
+*       </button>
+*       {isDrawing && (
+*         <button onClick={cancel}>
+*           Cancel ({activeShapeType})
+*         </button>
+*       )}
+*     </div>
+*   );
+* }
+* ```
+*
+* @example
+* ```tsx
+* // Outside MapProvider - pass mapId directly
+* function ExternalDrawingControl({ mapId }: { mapId: UniqueId }) {
+*   const { draw, isDrawing } = useDrawShape(mapId);
+*
+*   return (
+*     <button
+*       onClick={() => draw(ShapeFeatureType.Point)}
+*       disabled={isDrawing}
+*     >
+*       Add Point
+*     </button>
+*   );
+* }
+* ```
+*/
+function useDrawShape(mapId, options) {
+	const contextId = useContext(MapContext);
+	const actualId = mapId ?? contextId;
+	if (!actualId) throw new Error("useDrawShape requires either a mapId parameter or to be used within a MapProvider");
+	const { onCreate, onCancel } = options ?? {};
+	const { state: drawingState, draw, cancel } = drawStore.use(actualId);
+	const { useOn: useOn$1 } = useBus();
+	useOn$1(DrawShapeEvents.drawn, (event) => {
+		if (event.payload.mapId === actualId && onCreate) onCreate(event.payload.shape);
+	});
+	useOn$1(DrawShapeEvents.canceled, (event) => {
+		if (event.payload.mapId === actualId && onCancel) onCancel(event.payload.shapeType);
+	});
+	return useMemo(() => ({
+		drawingState,
+		draw,
+		cancel,
+		isDrawing: !!drawingState?.activeShapeType,
+		activeShapeType: drawingState?.activeShapeType ?? null
+	}), [
+		drawingState,
+		draw,
+		cancel
+	]);
+}
+
+//#endregion
+export { useDrawShape };
+//# sourceMappingURL=use-draw-shape.js.map

package/dist/deckgl/shapes/draw-shape-layer/use-draw-shape.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-draw-shape.js","names":[],"sources":["../../../../src/deckgl/shapes/draw-shape-layer/use-draw-shape.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 'client-only';\nimport { useBus } from '@accelint/bus/react';\nimport { useContext, useMemo } from 'react';\nimport { MapContext } from '../../base-map/provider';\nimport { DrawShapeEvents } from './events';\nimport { drawStore } from './store';\nimport type { UniqueId } from '@accelint/core';\nimport type { DrawShapeEvent } from './events';\nimport type { UseDrawShapeOptions, UseDrawShapeReturn } from './types';\n\n/**\n * Hook to access the shape drawing state and actions.\n *\n * This hook uses `useSyncExternalStore` to subscribe to drawing state changes,\n * providing concurrent-safe state updates. Uses a fan-out pattern where\n * a single bus listener per map instance notifies N React component subscribers.\n *\n * @param mapId - Optional map instance ID. If not provided, will use the ID from `MapContext`.\n * @param options - Optional callbacks for onCreate and onCancel events\n * @returns Drawing state, draw function, cancel function, and convenience flags\n * @throws Error if no `mapId` is provided and hook is used outside of `MapProvider`\n *\n * @example\n * ```tsx\n * // Inside MapProvider (within BaseMap children) - uses context\n * function DrawingToolbar() {\n *   const { draw, cancel, isDrawing, activeShapeType } = useDrawShape(undefined, {\n *     onCreate: (shape) => {\n *       console.log('Shape created:', shape);\n *       setShapes(prev => [...prev, shape]);\n *     },\n *     onCancel: (shapeType) => {\n *       console.log('Drawing canceled:', shapeType);\n *     },\n *   });\n *\n *   return (\n *     <div>\n *       <button onClick={() => draw(ShapeFeatureType.Polygon)}>\n *         Draw Polygon\n *       </button>\n *       <button onClick={() => draw(ShapeFeatureType.Circle)}>\n *         Draw Circle\n *       </button>\n *       {isDrawing && (\n *         <button onClick={cancel}>\n *           Cancel ({activeShapeType})\n *         </button>\n *       )}\n *     </div>\n *   );\n * }\n * ```\n *\n * @example\n * ```tsx\n * // Outside MapProvider - pass mapId directly\n * function ExternalDrawingControl({ mapId }: { mapId: UniqueId }) {\n *   const { draw, isDrawing } = useDrawShape(mapId);\n *\n *   return (\n *     <button\n *       onClick={() => draw(ShapeFeatureType.Point)}\n *       disabled={isDrawing}\n *     >\n *       Add Point\n *     </button>\n *   );\n * }\n * ```\n */\nexport function useDrawShape(\n  mapId?: UniqueId,\n  options?: UseDrawShapeOptions,\n): UseDrawShapeReturn {\n  const contextId = useContext(MapContext);\n  const actualId = mapId ?? contextId;\n\n  if (!actualId) {\n    throw new Error(\n      'useDrawShape requires either a mapId parameter or to be used within a MapProvider',\n    );\n  }\n\n  const { onCreate, onCancel } = options ?? {};\n\n  // Use the v2 store API directly\n  const { state: drawingState, draw, cancel } = drawStore.use(actualId);\n\n  // Listen for completion/cancellation events to trigger callbacks\n  // useOn handles cleanup automatically and uses useEffectEvent for stable callbacks\n  const { useOn } = useBus<DrawShapeEvent>();\n\n  useOn(DrawShapeEvents.drawn, (event) => {\n    if (event.payload.mapId === actualId && onCreate) {\n      onCreate(event.payload.shape);\n    }\n  });\n\n  useOn(DrawShapeEvents.canceled, (event) => {\n    if (event.payload.mapId === actualId && onCancel) {\n      onCancel(event.payload.shapeType);\n    }\n  });\n\n  // Memoize the return value to prevent unnecessary re-renders\n  return useMemo(\n    () => ({\n      drawingState,\n      draw,\n      cancel,\n      isDrawing: !!drawingState?.activeShapeType,\n      activeShapeType: drawingState?.activeShapeType ?? null,\n    }),\n    [drawingState, draw, cancel],\n  );\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAqFA,SAAgB,aACd,OACA,SACoB;CACpB,MAAM,YAAY,WAAW,WAAW;CACxC,MAAM,WAAW,SAAS;AAE1B,KAAI,CAAC,SACH,OAAM,IAAI,MACR,oFACD;CAGH,MAAM,EAAE,UAAU,aAAa,WAAW,EAAE;CAG5C,MAAM,EAAE,OAAO,cAAc,MAAM,WAAW,UAAU,IAAI,SAAS;CAIrE,MAAM,EAAE,mBAAU,QAAwB;AAE1C,SAAM,gBAAgB,QAAQ,UAAU;AACtC,MAAI,MAAM,QAAQ,UAAU,YAAY,SACtC,UAAS,MAAM,QAAQ,MAAM;GAE/B;AAEF,SAAM,gBAAgB,WAAW,UAAU;AACzC,MAAI,MAAM,QAAQ,UAAU,YAAY,SACtC,UAAS,MAAM,QAAQ,UAAU;GAEnC;AAGF,QAAO,eACE;EACL;EACA;EACA;EACA,WAAW,CAAC,CAAC,cAAc;EAC3B,iBAAiB,cAAc,mBAAmB;EACnD,GACD;EAAC;EAAc;EAAM;EAAO,CAC7B"}

package/dist/deckgl/shapes/draw-shape-layer/utils/feature-conversion.js

@@ -0,0 +1,147 @@
+/*
+ * Copyright 2025 Hypergiant Galactic Systems Inc. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+
+'use client';
+
+import { DEFAULT_STYLE_PROPERTIES } from "../../shared/constants.js";
+import { ShapeFeatureType } from "../../shared/types.js";
+import { DEFAULT_DISTANCE_UNITS } from "../../../../shared/units.js";
+import { getLogger } from "@accelint/logger";
+import { uuid } from "@accelint/core";
+import { centroid, distance } from "@turf/turf";
+
+//#region src/deckgl/shapes/draw-shape-layer/utils/feature-conversion.ts
+const logger = getLogger({
+	enabled: process.env.NODE_ENV !== "production",
+	level: "warn",
+	prefix: "[FeatureConversion]",
+	pretty: true
+});
+/**
+* Generate a default name for a shape based on its type
+*/
+function generateShapeName(shape) {
+	return `New ${shape} (${(/* @__PURE__ */ new Date()).toLocaleTimeString()})`;
+}
+/**
+* Compute circle properties from a polygon geometry (circle approximation)
+*
+* The EditableGeoJsonLayer creates circles as polygon approximations.
+* This function extracts the center and radius from that polygon.
+*/
+function computeCircleProperties(geometry) {
+	const coordinates = geometry.coordinates[0];
+	if (!coordinates || coordinates.length < 3) {
+		logger.warn("Cannot compute circle properties: polygon has insufficient coordinates");
+		return;
+	}
+	const center = centroid({
+		type: "Polygon",
+		coordinates: geometry.coordinates
+	}).geometry.coordinates;
+	if (!(Number.isFinite(center[0]) && Number.isFinite(center[1]))) {
+		logger.warn("Cannot compute circle properties: invalid center coordinates");
+		return;
+	}
+	const firstPoint = coordinates[0];
+	if (!(firstPoint && Number.isFinite(firstPoint[0]) && Number.isFinite(firstPoint[1]))) {
+		logger.warn("Cannot compute circle properties: invalid edge point coordinates");
+		return;
+	}
+	const radius = distance(center, firstPoint, { units: DEFAULT_DISTANCE_UNITS });
+	if (!Number.isFinite(radius) || radius <= 0) {
+		logger.warn("Cannot compute circle properties: invalid radius computed");
+		return;
+	}
+	return {
+		center,
+		radius: {
+			value: radius,
+			units: DEFAULT_DISTANCE_UNITS
+		}
+	};
+}
+/**
+* Compute ellipse properties from a feature's editProperties
+*
+* The DrawEllipseUsingThreePointsMode attaches ellipse metadata to the feature's
+* properties.editProperties. This function extracts and normalizes that data.
+*/
+function computeEllipseProperties(feature) {
+	const editProps = feature.properties?.editProperties;
+	if (!editProps || editProps.shape !== "Ellipse") {
+		logger.warn("Cannot compute ellipse properties: feature missing editProperties or not an ellipse");
+		return;
+	}
+	return {
+		center: editProps.center,
+		xSemiAxis: {
+			value: editProps.xSemiAxis.value,
+			units: DEFAULT_DISTANCE_UNITS
+		},
+		ySemiAxis: {
+			value: editProps.ySemiAxis.value,
+			units: DEFAULT_DISTANCE_UNITS
+		},
+		angle: editProps.angle
+	};
+}
+/**
+* Convert a raw GeoJSON Feature from EditableGeoJsonLayer to a Shape
+*
+* The returned Shape includes:
+* - Auto-generated UUID
+* - Auto-generated name with timestamp (e.g., "New Polygon (2:30:45 PM)")
+* - Merged style properties (defaults + overrides)
+* - Circle/ellipse properties computed from geometry if applicable
+* - `lastUpdated` timestamp
+* - `locked: false` (newly created shapes are always unlocked)
+*
+* @param feature - The raw GeoJSON feature from the editable layer
+* @param shape - The type of shape being created
+* @param styleDefaults - Optional style overrides
+* @returns A complete Shape ready for use
+*/
+function convertFeatureToShape(feature, shape, styleDefaults) {
+	const id = uuid();
+	const name = generateShapeName(shape);
+	const styleProperties = {
+		...DEFAULT_STYLE_PROPERTIES,
+		...styleDefaults ?? {}
+	};
+	let circleProperties;
+	if (shape === ShapeFeatureType.Circle && feature.geometry.type === "Polygon") circleProperties = computeCircleProperties(feature.geometry);
+	let ellipseProperties;
+	if (shape === ShapeFeatureType.Ellipse && feature.geometry.type === "Polygon") ellipseProperties = computeEllipseProperties(feature);
+	return {
+		id,
+		name,
+		shape,
+		feature: {
+			type: "Feature",
+			geometry: feature.geometry,
+			properties: {
+				styleProperties,
+				circleProperties,
+				ellipseProperties,
+				shapeId: id
+			}
+		},
+		lastUpdated: Date.now(),
+		locked: false
+	};
+}
+
+//#endregion
+export { convertFeatureToShape };
+//# sourceMappingURL=feature-conversion.js.map

package/dist/deckgl/shapes/draw-shape-layer/utils/feature-conversion.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"feature-conversion.js","names":["styleProperties: StyleProperties","circleProperties: CircleProperties | undefined","ShapeFeatureTypeEnum","ellipseProperties: EllipseProperties | undefined"],"sources":["../../../../../src/deckgl/shapes/draw-shape-layer/utils/feature-conversion.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 { uuid } from '@accelint/core';\nimport { getLogger } from '@accelint/logger';\nimport { centroid, distance } from '@turf/turf';\nimport { DEFAULT_DISTANCE_UNITS } from '@/shared/units';\nimport { DEFAULT_STYLE_PROPERTIES } from '../../shared/constants';\nimport {\n  type CircleProperties,\n  type EllipseProperties,\n  type Shape,\n  type ShapeFeature,\n  type ShapeFeatureType,\n  ShapeFeatureType as ShapeFeatureTypeEnum,\n  type StyleProperties,\n} from '../../shared/types';\nimport type { Feature, Polygon, Position } from 'geojson';\n\nconst logger = getLogger({\n  enabled: process.env.NODE_ENV !== 'production',\n  level: 'warn',\n  prefix: '[FeatureConversion]',\n  pretty: true,\n});\n\n/**\n * Generate a default name for a shape based on its type\n */\nfunction generateShapeName(shape: ShapeFeatureType): string {\n  const timestamp = new Date().toLocaleTimeString();\n  return `New ${shape} (${timestamp})`;\n}\n\n/**\n * Compute circle properties from a polygon geometry (circle approximation)\n *\n * The EditableGeoJsonLayer creates circles as polygon approximations.\n * This function extracts the center and radius from that polygon.\n */\nfunction computeCircleProperties(\n  geometry: Polygon,\n): CircleProperties | undefined {\n  const coordinates = geometry.coordinates[0];\n  if (!coordinates || coordinates.length < 3) {\n    logger.warn(\n      'Cannot compute circle properties: polygon has insufficient coordinates',\n    );\n    return undefined;\n  }\n\n  // Calculate center using turf centroid\n  const centerFeature = centroid({\n    type: 'Polygon',\n    coordinates: geometry.coordinates,\n  });\n  const center = centerFeature.geometry.coordinates as [number, number];\n\n  // Validate center coordinates are valid numbers\n  const isCenterValid =\n    Number.isFinite(center[0]) && Number.isFinite(center[1]);\n  if (!isCenterValid) {\n    logger.warn('Cannot compute circle properties: invalid center coordinates');\n    return undefined;\n  }\n\n  // Calculate radius as distance from center to first point\n  const firstPoint = coordinates[0] as Position;\n\n  // Validate first point coordinates\n  const isFirstPointValid =\n    firstPoint &&\n    Number.isFinite(firstPoint[0]) &&\n    Number.isFinite(firstPoint[1]);\n  if (!isFirstPointValid) {\n    logger.warn(\n      'Cannot compute circle properties: invalid edge point coordinates',\n    );\n    return undefined;\n  }\n\n  const radius = distance(center, firstPoint, {\n    units: DEFAULT_DISTANCE_UNITS,\n  });\n\n  // Validate computed radius\n  if (!Number.isFinite(radius) || radius <= 0) {\n    logger.warn('Cannot compute circle properties: invalid radius computed');\n    return undefined;\n  }\n\n  return {\n    center,\n    radius: {\n      value: radius,\n      units: DEFAULT_DISTANCE_UNITS,\n    },\n  };\n}\n\n/**\n * Edit properties attached by DrawEllipseUsingThreePointsMode\n */\ninterface EllipseEditProperties {\n  shape: 'Ellipse';\n  xSemiAxis: { value: number; unit: string };\n  ySemiAxis: { value: number; unit: string };\n  angle: number;\n  center: [number, number];\n}\n\n/**\n * Compute ellipse properties from a feature's editProperties\n *\n * The DrawEllipseUsingThreePointsMode attaches ellipse metadata to the feature's\n * properties.editProperties. This function extracts and normalizes that data.\n */\nfunction computeEllipseProperties(\n  feature: Feature,\n): EllipseProperties | undefined {\n  const editProps = (\n    feature.properties as { editProperties?: EllipseEditProperties } | null\n  )?.editProperties;\n\n  if (!editProps || editProps.shape !== 'Ellipse') {\n    logger.warn(\n      'Cannot compute ellipse properties: feature missing editProperties or not an ellipse',\n    );\n    return undefined;\n  }\n\n  return {\n    center: editProps.center,\n    xSemiAxis: {\n      value: editProps.xSemiAxis.value,\n      units: DEFAULT_DISTANCE_UNITS,\n    },\n    ySemiAxis: {\n      value: editProps.ySemiAxis.value,\n      units: DEFAULT_DISTANCE_UNITS,\n    },\n    angle: editProps.angle,\n  };\n}\n\n/**\n * Convert a raw GeoJSON Feature from EditableGeoJsonLayer to a Shape\n *\n * The returned Shape includes:\n * - Auto-generated UUID\n * - Auto-generated name with timestamp (e.g., \"New Polygon (2:30:45 PM)\")\n * - Merged style properties (defaults + overrides)\n * - Circle/ellipse properties computed from geometry if applicable\n * - `lastUpdated` timestamp\n * - `locked: false` (newly created shapes are always unlocked)\n *\n * @param feature - The raw GeoJSON feature from the editable layer\n * @param shape - The type of shape being created\n * @param styleDefaults - Optional style overrides\n * @returns A complete Shape ready for use\n */\nexport function convertFeatureToShape(\n  feature: Feature,\n  shape: ShapeFeatureType,\n  styleDefaults?: Partial<StyleProperties> | null,\n): Shape {\n  const id = uuid();\n  const name = generateShapeName(shape);\n\n  // Merge default styles with any provided defaults\n  const styleProperties: StyleProperties = {\n    ...DEFAULT_STYLE_PROPERTIES,\n    ...(styleDefaults ?? {}),\n  };\n\n  // Compute circle properties if this is a circle\n  let circleProperties: CircleProperties | undefined;\n  if (\n    shape === ShapeFeatureTypeEnum.Circle &&\n    feature.geometry.type === 'Polygon'\n  ) {\n    circleProperties = computeCircleProperties(feature.geometry);\n  }\n\n  // Compute ellipse properties if this is an ellipse\n  let ellipseProperties: EllipseProperties | undefined;\n  if (\n    shape === ShapeFeatureTypeEnum.Ellipse &&\n    feature.geometry.type === 'Polygon'\n  ) {\n    ellipseProperties = computeEllipseProperties(feature);\n  }\n\n  // Create the styled feature\n  const styledFeature: ShapeFeature = {\n    type: 'Feature',\n    geometry: feature.geometry,\n    properties: {\n      styleProperties,\n      circleProperties,\n      ellipseProperties,\n      shapeId: id,\n    },\n  };\n\n  // Type assertion needed because TypeScript can't narrow the return type\n  // based on the runtime shape value. The constructed object satisfies\n  // the Shape union at runtime based on which shape was passed in.\n  return {\n    id,\n    name,\n    shape,\n    feature: styledFeature,\n    lastUpdated: Date.now(),\n    locked: false,\n  } as Shape;\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;AA8BA,MAAM,SAAS,UAAU;CACvB,SAAS,QAAQ,IAAI,aAAa;CAClC,OAAO;CACP,QAAQ;CACR,QAAQ;CACT,CAAC;;;;AAKF,SAAS,kBAAkB,OAAiC;AAE1D,QAAO,OAAO,MAAM,qBADF,IAAI,MAAM,EAAC,oBAAoB,CACf;;;;;;;;AASpC,SAAS,wBACP,UAC8B;CAC9B,MAAM,cAAc,SAAS,YAAY;AACzC,KAAI,CAAC,eAAe,YAAY,SAAS,GAAG;AAC1C,SAAO,KACL,yEACD;AACD;;CAQF,MAAM,SAJgB,SAAS;EAC7B,MAAM;EACN,aAAa,SAAS;EACvB,CAAC,CAC2B,SAAS;AAKtC,KAAI,EADF,OAAO,SAAS,OAAO,GAAG,IAAI,OAAO,SAAS,OAAO,GAAG,GACtC;AAClB,SAAO,KAAK,+DAA+D;AAC3E;;CAIF,MAAM,aAAa,YAAY;AAO/B,KAAI,EAHF,cACA,OAAO,SAAS,WAAW,GAAG,IAC9B,OAAO,SAAS,WAAW,GAAG,GACR;AACtB,SAAO,KACL,mEACD;AACD;;CAGF,MAAM,SAAS,SAAS,QAAQ,YAAY,EAC1C,OAAO,wBACR,CAAC;AAGF,KAAI,CAAC,OAAO,SAAS,OAAO,IAAI,UAAU,GAAG;AAC3C,SAAO,KAAK,4DAA4D;AACxE;;AAGF,QAAO;EACL;EACA,QAAQ;GACN,OAAO;GACP,OAAO;GACR;EACF;;;;;;;;AAoBH,SAAS,yBACP,SAC+B;CAC/B,MAAM,YACJ,QAAQ,YACP;AAEH,KAAI,CAAC,aAAa,UAAU,UAAU,WAAW;AAC/C,SAAO,KACL,sFACD;AACD;;AAGF,QAAO;EACL,QAAQ,UAAU;EAClB,WAAW;GACT,OAAO,UAAU,UAAU;GAC3B,OAAO;GACR;EACD,WAAW;GACT,OAAO,UAAU,UAAU;GAC3B,OAAO;GACR;EACD,OAAO,UAAU;EAClB;;;;;;;;;;;;;;;;;;AAmBH,SAAgB,sBACd,SACA,OACA,eACO;CACP,MAAM,KAAK,MAAM;CACjB,MAAM,OAAO,kBAAkB,MAAM;CAGrC,MAAMA,kBAAmC;EACvC,GAAG;EACH,GAAI,iBAAiB,EAAE;EACxB;CAGD,IAAIC;AACJ,KACE,UAAUC,iBAAqB,UAC/B,QAAQ,SAAS,SAAS,UAE1B,oBAAmB,wBAAwB,QAAQ,SAAS;CAI9D,IAAIC;AACJ,KACE,UAAUD,iBAAqB,WAC/B,QAAQ,SAAS,SAAS,UAE1B,qBAAoB,yBAAyB,QAAQ;AAkBvD,QAAO;EACL;EACA;EACA;EACA,SAlBkC;GAClC,MAAM;GACN,UAAU,QAAQ;GAClB,YAAY;IACV;IACA;IACA;IACA,SAAS;IACV;GACF;EAUC,aAAa,KAAK,KAAK;EACvB,QAAQ;EACT"}

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

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2025 Hypergiant Galactic Systems Inc. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+
+'use client';
+
+import { COMPLETION_EDIT_TYPES, CONTINUOUS_EDIT_TYPES } from "../shared/constants.js";
+
+//#region src/deckgl/shapes/edit-shape-layer/constants.ts
+/**
+* Mode name for the map-mode integration
+*/
+const EDIT_SHAPE_MODE = "edit-shape";
+/**
+* Identifier for the edit shape layer.
+* Used as the owner for map-mode/cursor and as the default layer ID.
+*/
+const EDIT_SHAPE_LAYER_ID = "edit-shape-layer";
+/**
+* Cursor mapping for each edit mode
+*/
+const EDIT_CURSOR_MAP = {
+	view: "default",
+	"bounding-transform": "crosshair",
+	"vertex-transform": "crosshair",
+	"circle-transform": "crosshair",
+	translate: "crosshair"
+};
+
+//#endregion
+export { EDIT_CURSOR_MAP, EDIT_SHAPE_LAYER_ID, EDIT_SHAPE_MODE };
+//# sourceMappingURL=constants.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"constants.js","names":["EDIT_CURSOR_MAP: Record<EditMode, CSSCursorType>"],"sources":["../../../../src/deckgl/shapes/edit-shape-layer/constants.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 type { CSSCursorType } from '@/map-cursor/types';\nimport type { EditMode } from './types';\n\n// Re-export edit event type sets from shared constants\nexport {\n  COMPLETION_EDIT_TYPES,\n  CONTINUOUS_EDIT_TYPES,\n} from '../shared/constants';\n\n/**\n * Mode name for the map-mode integration\n */\nexport const EDIT_SHAPE_MODE = 'edit-shape';\n\n/**\n * Identifier for the edit shape layer.\n * Used as the owner for map-mode/cursor and as the default layer ID.\n */\nexport const EDIT_SHAPE_LAYER_ID = 'edit-shape-layer';\n\n/**\n * Cursor mapping for each edit mode\n */\nexport const EDIT_CURSOR_MAP: Record<EditMode, CSSCursorType> = {\n  view: 'default',\n  'bounding-transform': 'crosshair',\n  'vertex-transform': 'crosshair',\n  'circle-transform': 'crosshair',\n  translate: 'crosshair',\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;AA0BA,MAAa,kBAAkB;;;;;AAM/B,MAAa,sBAAsB;;;;AAKnC,MAAaA,kBAAmD;CAC9D,MAAM;CACN,sBAAsB;CACtB,oBAAoB;CACpB,oBAAoB;CACpB,WAAW;CACZ"}

package/dist/deckgl/shapes/edit-shape-layer/events.d.ts

@@ -0,0 +1,92 @@
+/*
+ * Copyright 2025 Hypergiant Galactic Systems Inc. All rights reserved.
+ * This file is licensed to you under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License. You may obtain a copy
+ * of the License at https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software distributed under
+ * the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS
+ * OF ANY KIND, either express or implied. See the License for the specific language
+ * governing permissions and limitations under the License.
+ */
+
+import { Shape } from "../shared/types.js";
+import { UniqueId } from "@accelint/core";
+
+//#region src/deckgl/shapes/edit-shape-layer/events.d.ts
+/**
+ * Edit shape lifecycle events
+ */
+declare const EditShapeEvents: {
+  /** Editing has started for a shape */
+  readonly editing: "shapes:editing";
+  /** Shape has been successfully updated */
+  readonly updated: "shapes:updated";
+  /** Editing was canceled */
+  readonly canceled: "shapes:edit-canceled";
+};
+type EditShapeEventType = (typeof EditShapeEvents)[keyof typeof EditShapeEvents];
+/**
+ * Payload for shapes:editing event.
+ */
+type ShapeEditingPayload = {
+  /** The shape being edited */
+  shape: Shape;
+  /** Map instance ID for multi-map event isolation */
+  mapId: UniqueId;
+};
+/**
+ * Event payload for shapes:editing
+ * Emitted when editing starts
+ */
+type ShapeEditingEvent = {
+  type: 'shapes:editing';
+  payload: ShapeEditingPayload;
+  source: UniqueId;
+  target?: UniqueId;
+};
+/**
+ * Payload for shapes:updated event.
+ */
+type ShapeUpdatedPayload = {
+  /** The updated shape with new geometry */
+  shape: Shape;
+  /** Map instance ID for multi-map event isolation */
+  mapId: UniqueId;
+};
+/**
+ * Event payload for shapes:updated
+ * Emitted when shape edits are saved
+ */
+type ShapeUpdatedEvent = {
+  type: 'shapes:updated';
+  payload: ShapeUpdatedPayload;
+  source: UniqueId;
+  target?: UniqueId;
+};
+/**
+ * Payload for shapes:edit-canceled event.
+ */
+type ShapeEditCanceledPayload = {
+  /** The shape that was being edited (original, unchanged) */
+  shape: Shape;
+  /** Map instance ID for multi-map event isolation */
+  mapId: UniqueId;
+};
+/**
+ * Event payload for shapes:edit-canceled
+ * Emitted when editing is canceled
+ */
+type ShapeEditCanceledEvent = {
+  type: 'shapes:edit-canceled';
+  payload: ShapeEditCanceledPayload;
+  source: UniqueId;
+  target?: UniqueId;
+};
+/**
+ * Union of all edit shape event types
+ */
+type EditShapeEvent = ShapeEditingEvent | ShapeUpdatedEvent | ShapeEditCanceledEvent;
+//#endregion
+export { EditShapeEvent, EditShapeEventType, EditShapeEvents, ShapeEditCanceledEvent, ShapeEditCanceledPayload, ShapeEditingEvent, ShapeEditingPayload, ShapeUpdatedEvent, ShapeUpdatedPayload };
+//# sourceMappingURL=events.d.ts.map