@accelint/map-toolkit 0.5.0 → 1.0.0

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 2025 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 { uuid } from "@accelint/core";
+import { getLogger } from "@accelint/logger";
+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 2025 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 2025 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

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

@@ -0,0 +1,56 @@
+/*
+ * 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';
+
+//#region src/deckgl/shapes/edit-shape-layer/events.ts
+/**
+* Edit Shape Events
+*
+* Note on event payload structure:
+* These events define explicit payload types rather than using the `Payload<T, P>` helper
+* from @accelint/bus. This is because the `Shape` type contains GeoJSON `Feature` objects
+* from the `geojson` package, which don't satisfy TypeScript's `StructuredCloneable` type
+* constraint used by the bus.
+*
+* The issue: `StructuredCloneable` (from type-fest) requires objects to have an index
+* signature `[key: string]: StructuredCloneable`, but GeoJSON interfaces define strict
+* property types without index signatures. At runtime, GeoJSON data IS structurally
+* cloneable (can be passed through postMessage, stored in IndexedDB, etc.), but
+* TypeScript can't verify this statically.
+*
+* Events that only contain primitive values (like ShapeId, mapId) can use the `Payload`
+* helper directly - see shared/events.ts for examples.
+*
+* When emitting these events via the bus, use type assertions:
+* @example
+* ```ts
+* bus.emit('shapes:updated', {
+*   type: 'shapes:updated',
+*   payload: { shape, mapId },
+*   source: componentId,
+* } as unknown as Payload);
+* ```
+*/
+/**
+* Edit shape lifecycle events
+*/
+const EditShapeEvents = {
+	editing: "shapes:editing",
+	updated: "shapes:updated",
+	canceled: "shapes:edit-canceled"
+};
+
+//#endregion
+export { EditShapeEvents };
+//# sourceMappingURL=events.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"events.js","names":[],"sources":["../../../../src/deckgl/shapes/edit-shape-layer/events.ts"],"sourcesContent":["/*\n * Copyright 2025 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/**\n * Edit Shape Events\n *\n * Note on event payload structure:\n * These events define explicit payload types rather than using the `Payload<T, P>` helper\n * from @accelint/bus. This is because the `Shape` type contains GeoJSON `Feature` objects\n * from the `geojson` package, which don't satisfy TypeScript's `StructuredCloneable` type\n * constraint used by the bus.\n *\n * The issue: `StructuredCloneable` (from type-fest) requires objects to have an index\n * signature `[key: string]: StructuredCloneable`, but GeoJSON interfaces define strict\n * property types without index signatures. At runtime, GeoJSON data IS structurally\n * cloneable (can be passed through postMessage, stored in IndexedDB, etc.), but\n * TypeScript can't verify this statically.\n *\n * Events that only contain primitive values (like ShapeId, mapId) can use the `Payload`\n * helper directly - see shared/events.ts for examples.\n *\n * When emitting these events via the bus, use type assertions:\n * @example\n * ```ts\n * bus.emit('shapes:updated', {\n *   type: 'shapes:updated',\n *   payload: { shape, mapId },\n *   source: componentId,\n * } as unknown as Payload);\n * ```\n */\n\n'use client';\n\nimport type { UniqueId } from '@accelint/core';\nimport type { Shape } from '../shared/types';\n\n/**\n * Edit shape lifecycle events\n */\nexport const EditShapeEvents = {\n  /** Editing has started for a shape */\n  editing: 'shapes:editing',\n  /** Shape has been successfully updated */\n  updated: 'shapes:updated',\n  /** Editing was canceled */\n  canceled: 'shapes:edit-canceled',\n} as const;\n\nexport type EditShapeEventType =\n  (typeof EditShapeEvents)[keyof typeof EditShapeEvents];\n\n/**\n * Payload for shapes:editing event.\n */\nexport type ShapeEditingPayload = {\n  /** The shape being edited */\n  shape: Shape;\n  /** Map instance ID for multi-map event isolation */\n  mapId: UniqueId;\n};\n\n/**\n * Event payload for shapes:editing\n * Emitted when editing starts\n */\nexport type ShapeEditingEvent = {\n  type: 'shapes:editing';\n  payload: ShapeEditingPayload;\n  source: UniqueId;\n  target?: UniqueId;\n};\n\n/**\n * Payload for shapes:updated event.\n */\nexport type ShapeUpdatedPayload = {\n  /** The updated shape with new geometry */\n  shape: Shape;\n  /** Map instance ID for multi-map event isolation */\n  mapId: UniqueId;\n};\n\n/**\n * Event payload for shapes:updated\n * Emitted when shape edits are saved\n */\nexport type ShapeUpdatedEvent = {\n  type: 'shapes:updated';\n  payload: ShapeUpdatedPayload;\n  source: UniqueId;\n  target?: UniqueId;\n};\n\n/**\n * Payload for shapes:edit-canceled event.\n */\nexport type ShapeEditCanceledPayload = {\n  /** The shape that was being edited (original, unchanged) */\n  shape: Shape;\n  /** Map instance ID for multi-map event isolation */\n  mapId: UniqueId;\n};\n\n/**\n * Event payload for shapes:edit-canceled\n * Emitted when editing is canceled\n */\nexport type ShapeEditCanceledEvent = {\n  type: 'shapes:edit-canceled';\n  payload: ShapeEditCanceledPayload;\n  source: UniqueId;\n  target?: UniqueId;\n};\n\n/**\n * Union of all edit shape event types\n */\nexport type EditShapeEvent =\n  | ShapeEditingEvent\n  | ShapeUpdatedEvent\n  | ShapeEditCanceledEvent;\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiDA,MAAa,kBAAkB;CAE7B,SAAS;CAET,SAAS;CAET,UAAU;CACX"}

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

@@ -0,0 +1,13 @@
+/*
+ * 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 "../draw-shape-layer/fiber.js";

package/dist/{node_modules/.pnpm/@math.gl_web-mercator@4.1.0/node_modules/@math.gl/web-mercator/dist/web-mercator-viewport.js → deckgl/shapes/edit-shape-layer/fiber.js}

@@ -11,6 +11,4 @@
  */
 
 
-import "./web-mercator-utils.js";
-import "./fit-bounds.js";
-import "./get-bounds.js";
+import "../draw-shape-layer/fiber.js";

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

@@ -0,0 +1,63 @@
+/*
+ * 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 { EditShapeLayerProps } from "./types.js";
+import * as react_jsx_runtime3 from "react/jsx-runtime";
+
+//#region src/deckgl/shapes/edit-shape-layer/index.d.ts
+
+/**
+ * EditShapeLayer - A React component for editing existing shapes on the map.
+ *
+ * This component wraps the EditableGeoJsonLayer from @deck.gl-community/editable-layers
+ * and integrates with the map-mode and map-cursor systems for proper coordination.
+ *
+ * Key features:
+ * - Renders only when actively editing (returns null otherwise)
+ * - Uses cached mode instances to prevent deck.gl assertion errors
+ * - Integrates with the editing store for state management
+ * - Neutral mode authorization (lets UI decide how to handle mode conflicts)
+ * - Circles use ResizeCircleMode with tooltip, other shapes use ModifyMode
+ * - Fill colors rendered at 20% opacity, edit handles are white
+ * - Live dimension/area tooltips during editing
+ * - requestAnimationFrame() batching for smooth drag performance
+ *
+ * @example
+ * ```tsx
+ * // Import the fiber registration for JSX support
+ * import '@accelint/map-toolkit/deckgl/shapes/edit-shape-layer/fiber';
+ * import '@accelint/map-toolkit/deckgl/shapes/display-shape-layer/fiber';
+ *
+ * function Map({ mapId }) {
+ *   const { editingShape } = useEditShape(mapId);
+ *
+ *   return (
+ *     <BaseMap id={mapId}>
+ *       <displayShapeLayer
+ *         data={shapes}
+ *         mapId={mapId}
+ *         selectedShapeId={editingShape?.id}
+ *       />
+ *       <EditShapeLayer mapId={mapId} />
+ *     </BaseMap>
+ *   );
+ * }
+ * ```
+ */
+declare function EditShapeLayer({
+  id,
+  mapId,
+  unit
+}: EditShapeLayerProps): react_jsx_runtime3.JSX.Element | null;
+//#endregion
+export { EditShapeLayer };
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,162 @@
+/*
+ * 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 { COMPLETION_EDIT_TYPES, CONTINUOUS_EDIT_TYPES } from "../shared/constants.js";
+import { getFillColor, getLineColor } from "../shared/utils/style-utils.js";
+import { ShapeFeatureType } from "../shared/types.js";
+import { useShiftZoomDisable } from "../shared/hooks/use-shift-zoom-disable.js";
+import { getDefaultEditableLayerProps } from "../shared/utils/layer-config.js";
+import { EDIT_SHAPE_LAYER_ID } from "./constants.js";
+import { getEditModeInstance } from "./modes/index.js";
+import { cancelEditingFromLayer, editStore, updateFeatureFromLayer } from "./store.js";
+import { useContext, useEffect, useRef } from "react";
+import { jsx } from "react/jsx-runtime";
+
+//#region src/deckgl/shapes/edit-shape-layer/index.tsx
+function isContinuousEditType(editType) {
+	return CONTINUOUS_EDIT_TYPES.has(editType);
+}
+function isCompletionEditType(editType) {
+	return COMPLETION_EDIT_TYPES.has(editType);
+}
+/**
+* Convert a GeoJSON Feature to a FeatureCollection for EditableGeoJsonLayer.
+* The editable-layers library accepts standard GeoJSON FeatureCollection at runtime,
+* but has stricter internal types. We use the geojson types which are compatible.
+*
+* For circles, adds the `shape: 'Circle'` property required by ResizeCircleMode.
+* ResizeCircleMode checks `properties.shape.includes('Circle')` to identify circles.
+*
+* For rectangles, adds the `shape: 'Rectangle'` property required by ModifyMode's
+* lockRectangles feature. ModifyMode checks `properties.shape === 'Rectangle'`.
+*/
+function toFeatureCollection(feature, shape) {
+	let shapeProperty;
+	if (shape === ShapeFeatureType.Circle) shapeProperty = "Circle";
+	else if (shape === ShapeFeatureType.Rectangle) shapeProperty = "Rectangle";
+	return {
+		type: "FeatureCollection",
+		features: [shapeProperty ? {
+			...feature,
+			properties: {
+				...feature.properties,
+				shape: shapeProperty
+			}
+		} : feature]
+	};
+}
+/**
+* EditShapeLayer - A React component for editing existing shapes on the map.
+*
+* This component wraps the EditableGeoJsonLayer from @deck.gl-community/editable-layers
+* and integrates with the map-mode and map-cursor systems for proper coordination.
+*
+* Key features:
+* - Renders only when actively editing (returns null otherwise)
+* - Uses cached mode instances to prevent deck.gl assertion errors
+* - Integrates with the editing store for state management
+* - Neutral mode authorization (lets UI decide how to handle mode conflicts)
+* - Circles use ResizeCircleMode with tooltip, other shapes use ModifyMode
+* - Fill colors rendered at 20% opacity, edit handles are white
+* - Live dimension/area tooltips during editing
+* - requestAnimationFrame() batching for smooth drag performance
+*
+* @example
+* ```tsx
+* // Import the fiber registration for JSX support
+* import '@accelint/map-toolkit/deckgl/shapes/edit-shape-layer/fiber';
+* import '@accelint/map-toolkit/deckgl/shapes/display-shape-layer/fiber';
+*
+* function Map({ mapId }) {
+*   const { editingShape } = useEditShape(mapId);
+*
+*   return (
+*     <BaseMap id={mapId}>
+*       <displayShapeLayer
+*         data={shapes}
+*         mapId={mapId}
+*         selectedShapeId={editingShape?.id}
+*       />
+*       <EditShapeLayer mapId={mapId} />
+*     </BaseMap>
+*   );
+* }
+* ```
+*/
+function EditShapeLayer({ id = EDIT_SHAPE_LAYER_ID, mapId, unit }) {
+	const contextId = useContext(MapContext);
+	const actualMapId = mapId ?? contextId;
+	if (!actualMapId) throw new Error("EditShapeLayer requires either a mapId prop or to be used within a MapProvider");
+	const { state: editingState } = editStore.use(actualMapId);
+	useShiftZoomDisable(actualMapId, editingState?.editingShape != null);
+	const pendingUpdateRef = useRef(null);
+	useEffect(() => {
+		return () => {
+			if (pendingUpdateRef.current) cancelAnimationFrame(pendingUpdateRef.current.rafId);
+		};
+	}, []);
+	if (!editingState?.editingShape) return null;
+	const { editingShape, editMode, featureBeingEdited } = editingState;
+	const mode = getEditModeInstance(editMode);
+	const data = toFeatureCollection(featureBeingEdited ?? editingShape.feature, editingShape.shape);
+	const cancelPendingUpdate = () => {
+		if (pendingUpdateRef.current) {
+			cancelAnimationFrame(pendingUpdateRef.current.rafId);
+			pendingUpdateRef.current = null;
+		}
+	};
+	const handleEdit = ({ updatedData, editType }) => {
+		const feature = updatedData.features[0];
+		if (isContinuousEditType(editType) && feature) {
+			cancelPendingUpdate();
+			pendingUpdateRef.current = {
+				feature,
+				rafId: requestAnimationFrame(() => {
+					updateFeatureFromLayer(actualMapId, feature);
+					pendingUpdateRef.current = null;
+				})
+			};
+			return;
+		}
+		if (isCompletionEditType(editType)) {
+			cancelPendingUpdate();
+			if (feature) updateFeatureFromLayer(actualMapId, feature);
+			return;
+		}
+		if (editType === "cancelFeature") {
+			cancelPendingUpdate();
+			cancelEditingFromLayer(actualMapId);
+		}
+	};
+	const fillColor = getFillColor(editingShape.feature, true);
+	const lineColor = getLineColor(editingShape.feature);
+	return /* @__PURE__ */ jsx("editableGeoJsonLayer", {
+		id,
+		data,
+		mode,
+		selectedFeatureIndexes: [0],
+		onEdit: handleEdit,
+		getFillColor: fillColor,
+		getLineColor: lineColor,
+		getTentativeFillColor: fillColor,
+		getTentativeLineColor: lineColor,
+		...getDefaultEditableLayerProps(unit)
+	});
+}
+
+//#endregion
+export { EditShapeLayer };
+//# sourceMappingURL=index.js.map