@accelint/design-toolkit 8.1.2 → 9.0.0

package/dist/components/coordinate-field/coordinate-utils.js

@@ -1,2 +1,793 @@
-import {getLogger}from'@accelint/logger';import {createCoordinate,coordinateSystems}from'@accelint/geo';import {COORDINATE_SYSTEMS}from'./types.js';const u=getLogger({enabled:process.env.NODE_ENV!=="production",level:"debug",prefix:"[CoordinateField]",pretty:true});const h=1e-6,l={INVALID:"Invalid coordinate",CONVERSION_FAILED:"Conversion failed",NOT_AVAILABLE_AT_POLES:"Not available at poles"};function S(t){if(t.length<2)return null;const r=Number.parseFloat(t[0]),n=Number.parseFloat(t[1]);if(Number.isNaN(r)||Number.isNaN(n))return null;const e=r>=0?"N":"S",a=n>=0?"E":"W";return `${Math.abs(r)} ${e} / ${Math.abs(n)} ${a}`}function C(t){return t.length<6?null:`${t[0]}\xB0 ${t[1]}' ${t[2]}, ${t[3]}\xB0 ${t[4]}' ${t[5]}`}function p(t){return t.length<8?null:`${t[0]}\xB0 ${t[1]}' ${t[2]}" ${t[3]}, ${t[4]}\xB0 ${t[5]}' ${t[6]}" ${t[7]}`}function N(t){return t.length<5?null:`${t[0]}${t[1]} ${t[2]} ${t[3]} ${t[4]}`}function b(t){return t.length<4?null:`${t[0]}${t[1]} ${t[2]} ${t[3]}`}function f(t,r){if(t.some(n=>n===""||n===void 0))return null;try{switch(r){case "dd":return S(t);case "ddm":return C(t);case "dms":return p(t);case "mgrs":return N(t);case "utm":return b(t);default:return null}}catch{return null}}function y(t){const r=t.match(/([-]?\d+\.?\d*)°?\s*([NS])?\s*[,/\s]+\s*([-]?\d+\.?\d*)°?\s*([EW])?/i);if(!r)return null;let n=r[1],e=r[3];return n&&e?(r[2]?.toUpperCase()==="S"&&!n.startsWith("-")&&(n=`-${n}`),r[4]?.toUpperCase()==="W"&&!e.startsWith("-")&&(e=`-${e}`),[n,e]):null}function D(t){const r=t.match(/(\d+)°?\s+([\d.]+)'?\s+([NS])\s*[,/]\s*(\d+)°?\s+([\d.]+)'?\s+([EW])/i);return r?[r[1],r[2],r[3],r[4],r[5],r[6]]:null}function $(t){const r=t.match(/(\d+)°?\s+(\d+)'?\s+([\d.]+)"?\s+([NS])\s*[,/]\s*(\d+)°?\s+(\d+)'?\s+([\d.]+)"?\s+([EW])/i);return r?[r[1],r[2],r[3],r[4],r[5],r[6],r[7],r[8]]:null}function v(t){const r=t.match(/(\d+)([A-Z])\s+([A-Z]{2})\s+(\d+)\s+(\d+)/i);return r?[r[1],r[2],r[3],r[4],r[5]]:null}function A(t){const r=t.match(/(\d+)\s*([NS])\s+(\d+)\s+(\d+)/i);return r?[r[1],r[2],r[3],r[4]]:null}function V(t,r){if(!t)return null;try{switch(r){case "dd":return y(t);case "ddm":return D(t);case "dms":return $(t);case "mgrs":return v(t);case "utm":return A(t);default:return null}}catch{return null}}function k(t,r){if(!t||typeof t.lat!="number"||typeof t.lon!="number")return null;try{const n=createCoordinate(coordinateSystems.dd,"LATLON"),e=Number(t.lat.toFixed(5)),a=Number(t.lon.toFixed(5)),s=`${e} / ${a}`,i=n(s);if(!i.valid)return null;let o;switch(r){case "dd":o=i.dd();break;case "ddm":o=i.ddm();break;case "dms":o=i.dms();break;case "mgrs":o=i.mgrs();break;case "utm":o=i.utm();break;default:return null}return V(o,r)}catch(n){return u.withContext({value:String(t),format:String(r)}).withError(n).error("Failed to convert DD to display"),null}}function x(t,r){const n=f(t,r);if(!n)return null;try{const a=createCoordinate(coordinateSystems[r],"LATLON")(n);if(!a.valid)return null;const{LAT:s,LON:i}=a.raw;return {lat:s,lon:i}}catch(e){return u.withContext({segments:JSON.stringify(t),format:String(r)}).withError(e).error("Failed to convert display to DD"),null}}function _(t,r){if(t.some(e=>e===""||e===void 0))return [];const n=f(t,r);if(!n)return ["Invalid coordinate value"];try{return createCoordinate(coordinateSystems[r],"LATLON")(n).valid?[]:["Invalid coordinate value"]}catch{return ["Invalid coordinate value"]}}function P(t){return t.every(r=>r!==""&&r!==void 0)}function U(t){return t.some(r=>r!==""&&r!==void 0)}function L(){return {dd:{value:l.INVALID,isValid:false},ddm:{value:l.INVALID,isValid:false},dms:{value:l.INVALID,isValid:false},mgrs:{value:l.INVALID,isValid:false},utm:{value:l.INVALID,isValid:false}}}function E(t){return t!==null&&typeof t.lat=="number"&&typeof t.lon=="number"}function I(t){const r=t instanceof Error?t.message:String(t);return r.includes("outside UTM limits")||r.includes("invalid UTM zone")}function M(t,r,n){try{let e;switch(r){case "dd":e=t.dd();break;case "ddm":e=t.ddm();break;case "dms":e=t.dms();break;case "mgrs":e=t.mgrs();break;case "utm":e=t.utm();break;default:return {value:l.INVALID,isValid:!1}}return {value:e,isValid:!0}}catch(e){return (r==="mgrs"||r==="utm")&&I(e)?{value:l.NOT_AVAILABLE_AT_POLES,isValid:false}:(u.withContext({value:JSON.stringify(n)}).withError(e).error(`Failed to convert to ${r}`),{value:l.CONVERSION_FAILED,isValid:false})}}function W(t){const r=L();if(!E(t))return r;const n=t;try{const a=createCoordinate(coordinateSystems.dd,"LATLON")(`${n.lat} / ${n.lon}`);if(!a.valid)return r;const s={};for(const i of COORDINATE_SYSTEMS)s[i]=M(a,i,n);return s}catch(e){return u.withContext({value:JSON.stringify(n)}).withError(e).error("Failed to get all coordinate formats"),r}}function G(t){if(!t||t.trim()==="")return  false;const r=/[,/]|°|′|″|['"]|\s{2,}/.test(t),e=(t.match(/\d+/g)||[]).length>=2,a=/^\d{1,2}[A-Z]\s+[A-Z]{2}\s+\d+\s+\d+$/i.test(t.trim()),s=/^\d{1,2}[NS]\s+\d+\s+\d+$/i.test(t.trim());return r||e||a||s}function Z(t){if(!t||t.trim()==="")return [];const r=[];for(const n of COORDINATE_SYSTEMS)try{const a=createCoordinate(coordinateSystems[n],"LATLON")(t.trim());if(a.valid){const{LAT:s,LON:i}=a.raw;let o;switch(n){case "dd":o=a.dd();break;case "ddm":o=a.ddm();break;case "dms":o=a.dms();break;case "mgrs":o=a.mgrs();break;case "utm":o=a.utm();break;default:o="";}r.push({format:n,value:{lat:s,lon:i},displayString:o});}}catch(e){u.withContext({pastedText:t.trim(),format:String(n)}).withError(e).warn(`Failed to parse as ${n}`);}return r}function O(t,r,n=h){return Math.abs(t.lat-r.lat)<n&&Math.abs(t.lon-r.lon)<n}function B(t){const r=[];for(const n of t)r.some(a=>O(a.value,n.value))||r.push(n);return r}export{h as COORDINATE_EPSILON,l as COORDINATE_ERROR_MESSAGES,P as areAllSegmentsFilled,O as areCoordinatesEqual,k as convertDDToDisplaySegments,x as convertDisplaySegmentsToDD,B as deduplicateMatchesByLocation,f as formatSegmentsToCoordinateString,W as getAllCoordinateFormats,U as hasAnySegmentValue,G as isCompleteCoordinate,Z as parseCoordinatePaste,V as parseCoordinateStringToSegments,_ as validateCoordinateSegments};//# sourceMappingURL=coordinate-utils.js.map
+/*
+ * 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 { COORDINATE_SYSTEMS } from "./types.js";
+import { getLogger } from "@accelint/logger";
+import { coordinateSystems, createCoordinate } from "@accelint/geo";
+
+//#region src/components/coordinate-field/coordinate-utils.ts
+/**
+* Coordinate Conversion Utilities
+*
+* This module provides utilities for converting between:
+* 1. Segment values (user input) → Coordinate strings (for @accelint/geo parsing)
+* 2. Coordinate strings (from @accelint/geo output) → Segment values (for display)
+* 3. Decimal Degrees (internal format) ↔ Display format segment values
+*
+* All conversions use the local @accelint/geo package for accurate coordinate parsing
+* and conversion between coordinate systems.
+*
+* ## Architecture: Bridge Layer Between UI and Geo Package
+*
+* This module serves as a bridge layer to handle the impedance mismatch between:
+* - **UI Requirements**: Individual segment fields (e.g., degrees, minutes, seconds, direction)
+* - **Geo Package API**: Complete coordinate strings (e.g., "40° 42' 46" N / 74° 0' 22" W")
+*
+* ### Why This Bridge Layer Exists
+*
+* The @accelint/geo package provides excellent coordinate parsing, validation, and conversion,
+* but its API is designed around complete coordinate strings:
+*
+* ```typescript
+* // What geo provides:
+* const coord = createCoordinate(coordinateSystems.ddm, 'LATLON')('40 42.768 N / 74 0.36 W');
+* coord.dd()   // Returns: "40.7128 N / 74.006 W"  (formatted string)
+* coord.ddm()  // Returns: "40 42.768 N / 74 0.36 W" (formatted string)
+* coord.raw    // Returns: { LAT: 40.7128, LON: -74.006 } (only DD numbers)
+* ```
+*
+* The coordinate-field component needs segment-level data for individual input fields:
+* - DDM: ['40', '42.768', 'N', '74', '0.36', 'W'] ← Not provided by geo
+* - DMS: ['40', '42', '46.08', 'N', '74', '0', '21.6', 'W'] ← Not provided by geo
+*
+* ### Current Limitations and Duplication
+*
+* Because the geo package only exposes:
+* 1. **Formatters** that return complete strings (coord.ddm(), coord.dms(), etc.)
+* 2. **Raw values** in Decimal Degrees only (coord.raw)
+*
+* This module must:
+* 1. Build coordinate strings from segments → Pass to geo for parsing
+* 2. Parse geo's formatted output strings → Extract segments using regex
+*
+* This creates a circular conversion flow for DD → Display Segments:
+* ```
+* DD value → String → Geo parse → Geo format → String → Regex parse → Segments
+* ```
+*
+* **Note on Duplication**: The regex parsing in this module duplicates work that the
+* geo package parsers already do internally. However, since geo doesn't expose the
+* parsed segment components (only formatted strings and raw DD values), we must
+* re-parse its output to extract the individual segments for the UI.
+*
+* ### What Would Eliminate This Duplication
+*
+* If the geo package exported component-level converters like:
+* ```typescript
+* // Hypothetical API that would eliminate the bridge layer:
+* export function ddToDdmComponents(dd: number): {
+*   degrees: number;
+*   minutes: number;
+*   direction: 'N' | 'S' | 'E' | 'W';
+* }
+* ```
+*
+* Then this bridge layer could be significantly simplified. The math for these conversions
+* exists in the geo package's formatters (e.g., formatDegreesDecimalMinutes), but it's
+* wrapped in string formatting logic rather than exposed as standalone utilities.
+*
+* ### Conversion Efficiency
+*
+* - **Efficient Path** (Display Segments → DD): Segments → String → Geo parse → DD
+*   - Uses geo package for all parsing and validation ✓
+*
+* - **Inefficient Path** (DD → Display Segments): DD → String → Geo parse → Geo format → Regex parse → Segments
+*   - Circular conversion with redundant string parsing/formatting ✗
+*   - Necessary given current geo API limitations
+*/
+const logger = getLogger({
+	enabled: process.env.NODE_ENV !== "production",
+	level: "debug",
+	prefix: "[CoordinateField]",
+	pretty: true
+});
+/** Epsilon for coordinate equality comparison (≈11cm precision at equator) */
+const COORDINATE_EPSILON = 1e-6;
+/**
+* Error message constants for coordinate format conversion
+* @internal
+*/
+const COORDINATE_ERROR_MESSAGES = {
+	INVALID: "Invalid coordinate",
+	CONVERSION_FAILED: "Conversion failed",
+	NOT_AVAILABLE_AT_POLES: "Not available at poles"
+};
+/**
+* Format DD (Decimal Degrees) segments to coordinate string
+*
+* Bridge function that builds a coordinate string from UI segment values
+* for passing to the geo package parser. Part of the Segments → String → Geo Parse flow.
+*
+* @internal
+*/
+function formatDDSegments(segments) {
+	if (segments.length < 2) return null;
+	const latNum = Number.parseFloat(segments[0]);
+	const lonNum = Number.parseFloat(segments[1]);
+	if (Number.isNaN(latNum) || Number.isNaN(lonNum)) return null;
+	const latDir = latNum >= 0 ? "N" : "S";
+	const lonDir = lonNum >= 0 ? "E" : "W";
+	return `${Math.abs(latNum)} ${latDir} / ${Math.abs(lonNum)} ${lonDir}`;
+}
+/**
+* Format DDM (Degrees Decimal Minutes) segments to coordinate string
+*
+* Bridge function that builds a coordinate string from UI segment values
+* for passing to the geo package parser. Part of the Segments → String → Geo Parse flow.
+*
+* @internal
+*/
+function formatDDMSegments(segments) {
+	if (segments.length < 6) return null;
+	return `${segments[0]}° ${segments[1]}' ${segments[2]}, ${segments[3]}° ${segments[4]}' ${segments[5]}`;
+}
+/**
+* Format DMS (Degrees Minutes Seconds) segments to coordinate string
+*
+* Bridge function that builds a coordinate string from UI segment values
+* for passing to the geo package parser. Part of the Segments → String → Geo Parse flow.
+*
+* @internal
+*/
+function formatDMSSegments(segments) {
+	if (segments.length < 8) return null;
+	return `${segments[0]}° ${segments[1]}' ${segments[2]}" ${segments[3]}, ${segments[4]}° ${segments[5]}' ${segments[6]}" ${segments[7]}`;
+}
+/**
+* Format MGRS (Military Grid Reference System) segments to coordinate string
+*
+* Bridge function that builds a coordinate string from UI segment values
+* for passing to the geo package parser. Part of the Segments → String → Geo Parse flow.
+*
+* @internal
+*/
+function formatMGRSSegments(segments) {
+	if (segments.length < 5) return null;
+	return `${segments[0]}${segments[1]} ${segments[2]} ${segments[3]} ${segments[4]}`;
+}
+/**
+* Format UTM (Universal Transverse Mercator) segments to coordinate string
+*
+* Bridge function that builds a coordinate string from UI segment values
+* for passing to the geo package parser. Part of the Segments → String → Geo Parse flow.
+*
+* @internal
+*/
+function formatUTMSegments(segments) {
+	if (segments.length < 4) return null;
+	return `${segments[0]}${segments[1]} ${segments[2]} ${segments[3]}`;
+}
+/**
+* Format segment values into a coordinate string suitable for @accelint/geo parsing
+*
+* Converts an array of segment values into a string format that the geo package
+* parsers can understand. Each format has different requirements:
+*
+* DD: [lat, lon] → "lat, lon"
+* DDM: [latDeg, latMin, latDir, lonDeg, lonMin, lonDir] → "latDeg° latMin' latDir, lonDeg° lonMin' lonDir"
+* DMS: [latDeg, latMin, latSec, latDir, lonDeg, lonMin, lonSec, lonDir] → "latDeg° latMin' latSec\" latDir, lonDeg° lonMin' lonSec\" lonDir"
+* MGRS: [zone, band, grid, easting, northing] → "zone+band grid easting northing"
+* UTM: [zone, hemisphere, easting, northing] → "zone+hemisphere easting northing"
+*
+* @param segments - Array of segment values from user input
+* @param format - The coordinate system format
+* @returns Formatted coordinate string, or null if segments are invalid
+*/
+function formatSegmentsToCoordinateString(segments, format) {
+	if (segments.some((seg) => seg === "" || seg === void 0)) return null;
+	try {
+		switch (format) {
+			case "dd": return formatDDSegments(segments);
+			case "ddm": return formatDDMSegments(segments);
+			case "dms": return formatDMSSegments(segments);
+			case "mgrs": return formatMGRSSegments(segments);
+			case "utm": return formatUTMSegments(segments);
+			default: return null;
+		}
+	} catch (_error) {
+		return null;
+	}
+}
+/**
+* Parse DD coordinate string to segments
+*
+* Extracts segment values from a formatted DD coordinate string. This duplicates
+* parsing logic from @accelint/geo's parseDecimalDegrees, but is necessary because
+* geo doesn't expose the parsed components - only formatted strings and raw DD numbers.
+*
+* Part of the Geo Format → String → Regex Parse → Segments flow (circular conversion).
+*
+* @internal
+*/
+function parseDDCoordinateString(coordString) {
+	const match = coordString.match(/([-]?\d+\.?\d*)°?\s*([NS])?\s*[,/\s]+\s*([-]?\d+\.?\d*)°?\s*([EW])?/i);
+	if (!match) return null;
+	let lat = match[1];
+	let lon = match[3];
+	if (!(lat && lon)) return null;
+	if (match[2]?.toUpperCase() === "S" && !lat.startsWith("-")) lat = `-${lat}`;
+	if (match[4]?.toUpperCase() === "W" && !lon.startsWith("-")) lon = `-${lon}`;
+	return [lat, lon];
+}
+/**
+* Parse DDM coordinate string to segments
+*
+* Extracts segment values from a formatted DDM coordinate string. This duplicates
+* parsing logic from @accelint/geo's parseDegreesDecimalMinutes, but is necessary because
+* geo doesn't expose the parsed components - only formatted strings and raw DD numbers.
+*
+* Part of the Geo Format → String → Regex Parse → Segments flow (circular conversion).
+*
+* @internal
+*/
+function parseDDMCoordinateString(coordString) {
+	const match = coordString.match(/(\d+)°?\s+([\d.]+)'?\s+([NS])\s*[,/]\s*(\d+)°?\s+([\d.]+)'?\s+([EW])/i);
+	if (!match) return null;
+	return [
+		match[1],
+		match[2],
+		match[3],
+		match[4],
+		match[5],
+		match[6]
+	];
+}
+/**
+* Parse DMS coordinate string to segments
+*
+* Extracts segment values from a formatted DMS coordinate string. This duplicates
+* parsing logic from @accelint/geo's parseDegreesMinutesSeconds, but is necessary because
+* geo doesn't expose the parsed components - only formatted strings and raw DD numbers.
+*
+* Part of the Geo Format → String → Regex Parse → Segments flow (circular conversion).
+*
+* @internal
+*/
+function parseDMSCoordinateString(coordString) {
+	const match = coordString.match(/(\d+)°?\s+(\d+)'?\s+([\d.]+)"?\s+([NS])\s*[,/]\s*(\d+)°?\s+(\d+)'?\s+([\d.]+)"?\s+([EW])/i);
+	if (!match) return null;
+	return [
+		match[1],
+		match[2],
+		match[3],
+		match[4],
+		match[5],
+		match[6],
+		match[7],
+		match[8]
+	];
+}
+/**
+* Parse MGRS coordinate string to segments
+*
+* Extracts segment values from a formatted MGRS coordinate string. This duplicates
+* parsing logic from @accelint/geo's parseMGRS, but is necessary because
+* geo doesn't expose the parsed components - only formatted strings and raw DD numbers.
+*
+* Part of the Geo Format → String → Regex Parse → Segments flow (circular conversion).
+*
+* @internal
+*/
+function parseMGRSCoordinateString(coordString) {
+	const match = coordString.match(/(\d+)([A-Z])\s+([A-Z]{2})\s+(\d+)\s+(\d+)/i);
+	if (!match) return null;
+	return [
+		match[1],
+		match[2],
+		match[3],
+		match[4],
+		match[5]
+	];
+}
+/**
+* Parse UTM coordinate string to segments
+*
+* Extracts segment values from a formatted UTM coordinate string. This duplicates
+* parsing logic from @accelint/geo's parseUTM, but is necessary because
+* geo doesn't expose the parsed components - only formatted strings and raw DD numbers.
+*
+* Part of the Geo Format → String → Regex Parse → Segments flow (circular conversion).
+*
+* @internal
+*/
+function parseUTMCoordinateString(coordString) {
+	const match = coordString.match(/(\d+)\s*([NS])\s+(\d+)\s+(\d+)/i);
+	if (!match) return null;
+	return [
+		match[1],
+		match[2],
+		match[3],
+		match[4]
+	];
+}
+/**
+* Parse a coordinate string into segment values
+*
+* Converts a formatted coordinate string (from @accelint/geo output or user input)
+* back into individual segment values for display.
+*
+* This is the inverse of formatSegmentsToCoordinateString.
+*
+* **Note on Duplication**: This function and its helpers (parseDDCoordinateString,
+* parseDDMCoordinateString, etc.) duplicate parsing logic that already exists in
+* the @accelint/geo package parsers:
+*
+* - Geo parsers: parseDecimalDegrees, parseDegreesDecimalMinutes, etc.
+* - These functions: parseDDCoordinateString, parseDDMCoordinateString, etc.
+*
+* Both use regex patterns to extract coordinate components from strings. The duplication
+* exists because:
+*
+* 1. **Geo parsers** extract components, validate them, convert to DD, then format back to strings
+* 2. **This function** extracts components from those formatted strings for the UI
+*
+* We're essentially undoing the formatting that geo just did. This is the second half
+* of the circular conversion described in convertDDToDisplaySegments.
+*
+* **Why we can't use geo parsers directly**: The geo parsers return coord objects with
+* only `coord.raw` (DD numbers) and formatting methods. They don't expose the parsed
+* segment components we need for the UI (e.g., the degrees, minutes, and direction values).
+*
+* **Parsing Order**:
+* - **convertDisplaySegmentsToDD**: Segments → String → **Geo parse** → DD ✓ (efficient)
+* - **convertDDToDisplaySegments**: DD → String → Geo parse → Geo format → **This parse** → Segments ✗ (circular)
+*
+* @param coordString - Formatted coordinate string
+* @param format - The coordinate system format
+* @returns Array of segment values, or null if parsing fails
+*/
+function parseCoordinateStringToSegments(coordString, format) {
+	if (!coordString) return null;
+	try {
+		switch (format) {
+			case "dd": return parseDDCoordinateString(coordString);
+			case "ddm": return parseDDMCoordinateString(coordString);
+			case "dms": return parseDMSCoordinateString(coordString);
+			case "mgrs": return parseMGRSCoordinateString(coordString);
+			case "utm": return parseUTMCoordinateString(coordString);
+			default: return null;
+		}
+	} catch (_error) {
+		return null;
+	}
+}
+/**
+* Convert DD (internal format) to display format segment values
+*
+* Takes a CoordinateValue in Decimal Degrees format and converts it to the
+* segment values needed for the specified display format.
+*
+* Uses @accelint/geo to ensure accurate conversion between coordinate systems.
+*
+* **Note on Circular Conversion**: This function demonstrates the circular conversion
+* pattern discussed in the module documentation. The flow is:
+*
+* 1. Start with DD value: `{ lat: 40.7128, lon: -74.0060 }`
+* 2. Convert to coordinate string: `"40.7128 / -74.006"`
+* 3. Parse with geo package (creates coord object with internal parsed state)
+* 4. Format to target system using geo: `coord.ddm()` → `"40 42.768 N / 74 0.36 W"`
+* 5. Parse the formatted string AGAIN with regex to extract segments: `['40', '42.768', 'N', ...]`
+*
+* This is inefficient because:
+* - The geo package already has the component values (degrees, minutes, direction) internally
+* - We format them into a string, then immediately parse the string back apart
+* - The regex parsing duplicates work the geo parsers already did
+*
+* However, this approach is necessary because:
+* - The geo package only exposes `coord.raw` (DD numbers) and formatted strings
+* - It doesn't expose the intermediate component values we need for the UI segments
+* - We need individual segment values for separate input fields
+*
+* **Future Improvement**: If geo package exported component extractors like:
+* ```typescript
+* coord.components.ddm // { latDeg: 40, latMin: 42.768, latDir: 'N', ... }
+* ```
+* Then we could eliminate the format→parse cycle entirely.
+*
+* @param value - Coordinate value in DD format `{ lat: number, lon: number }`
+* @param format - Target display format
+* @returns Array of segment values for display, or null if conversion fails
+*
+* @example
+* const segments = convertDDToDisplaySegments({ lat: 40.7128, lon: -74.0060 }, 'ddm');
+* // Returns: ['40', '42.7680', 'N', '74', '0.3600', 'W']
+*/
+function convertDDToDisplaySegments(value, format) {
+	if (!value || typeof value.lat !== "number" || typeof value.lon !== "number") return null;
+	try {
+		const coord = createCoordinate(coordinateSystems.dd, "LATLON")(`${Number(value.lat.toFixed(5))} / ${Number(value.lon.toFixed(5))}`);
+		if (!coord.valid) return null;
+		let coordString;
+		switch (format) {
+			case "dd":
+				coordString = coord.dd();
+				break;
+			case "ddm":
+				coordString = coord.ddm();
+				break;
+			case "dms":
+				coordString = coord.dms();
+				break;
+			case "mgrs":
+				coordString = coord.mgrs();
+				break;
+			case "utm":
+				coordString = coord.utm();
+				break;
+			default: return null;
+		}
+		return parseCoordinateStringToSegments(coordString, format);
+	} catch (error) {
+		logger.withContext({
+			value: String(value),
+			format: String(format)
+		}).withError(error).error("Failed to convert DD to display");
+		return null;
+	}
+}
+/**
+* Convert display format segment values to DD (internal format)
+*
+* Takes segment values from user input and converts them to a CoordinateValue
+* in Decimal Degrees format using @accelint/geo for validation and conversion.
+*
+* **Note on Efficiency**: This function demonstrates the EFFICIENT conversion direction.
+* The flow is:
+*
+* 1. Start with UI segments: `['40', '42.768', 'N', '74', '0.36', 'W']`
+* 2. Build coordinate string: `"40° 42.768' N, 74° 0.36' W"`
+* 3. Parse with geo package (validates and converts internally)
+* 4. Extract DD from coord.raw: `{ lat: 40.7128, lon: -74.0060 }`
+*
+* This is efficient because:
+* - We let geo do what it's designed for: parsing and validating coordinate strings
+* - We extract the DD values directly from `coord.raw` (no string parsing needed)
+* - Single direction: Segments → String → Geo Parse → DD (no circular conversion)
+*
+* Contrast with `convertDDToDisplaySegments` which has the circular pattern:
+* DD → String → Geo Parse → Geo Format → String → Regex Parse → Segments
+*
+* @param segments - Array of segment values from user input
+* @param format - The coordinate system format of the segments
+* @returns CoordinateValue in DD format, or null if invalid
+*
+* @example
+* const coord = convertDisplaySegmentsToDD(['40', '42.7680', 'N', '74', '0.3600', 'W'], 'ddm');
+* // Returns: { lat: 40.7128, lon: -74.0060 }
+*/
+function convertDisplaySegmentsToDD(segments, format) {
+	const coordString = formatSegmentsToCoordinateString(segments, format);
+	if (!coordString) return null;
+	try {
+		const coord = createCoordinate(coordinateSystems[format], "LATLON")(coordString);
+		if (!coord.valid) return null;
+		const { LAT, LON } = coord.raw;
+		return {
+			lat: LAT,
+			lon: LON
+		};
+	} catch (error) {
+		logger.withContext({
+			segments: JSON.stringify(segments),
+			format: String(format)
+		}).withError(error).error("Failed to convert display to DD");
+		return null;
+	}
+}
+/**
+* Validate coordinate segments and return errors
+*
+* Uses @accelint/geo to validate the segments and returns any validation errors.
+* Only validates when all required segments are filled.
+*
+* @param segments - Array of segment values from user input
+* @param format - The coordinate system format
+* @returns Array of error messages, empty if valid or incomplete
+*
+* @example
+* const errors = validateCoordinateSegments(['91', '0', 'N', '0', '0', 'E'], 'ddm');
+* // Returns: ['Invalid coordinate value']
+*/
+function validateCoordinateSegments(segments, format) {
+	if (segments.some((seg) => seg === "" || seg === void 0)) return [];
+	const coordString = formatSegmentsToCoordinateString(segments, format);
+	if (!coordString) return ["Invalid coordinate value"];
+	try {
+		if (!createCoordinate(coordinateSystems[format], "LATLON")(coordString).valid) return ["Invalid coordinate value"];
+		return [];
+	} catch (_error) {
+		return ["Invalid coordinate value"];
+	}
+}
+/**
+* Check if all segments are filled
+*
+* Helper to determine if the user has completed entering all segment values.
+* Used to determine when to trigger validation.
+*
+* @param segments - Array of segment values
+* @returns True if all segments have values, false otherwise
+*/
+function areAllSegmentsFilled(segments) {
+	return segments.every((seg) => seg !== "" && seg !== void 0);
+}
+/**
+* Check if any segments have values
+*
+* Helper to determine if the user has started entering coordinate values.
+*
+* @param segments - Array of segment values
+* @returns True if any segment has a value, false if all empty
+*/
+function hasAnySegmentValue(segments) {
+	return segments.some((seg) => seg !== "" && seg !== void 0);
+}
+/**
+* Create an invalid result object for all coordinate systems
+* @internal
+*/
+function createInvalidResult() {
+	return {
+		dd: {
+			value: COORDINATE_ERROR_MESSAGES.INVALID,
+			isValid: false
+		},
+		ddm: {
+			value: COORDINATE_ERROR_MESSAGES.INVALID,
+			isValid: false
+		},
+		dms: {
+			value: COORDINATE_ERROR_MESSAGES.INVALID,
+			isValid: false
+		},
+		mgrs: {
+			value: COORDINATE_ERROR_MESSAGES.INVALID,
+			isValid: false
+		},
+		utm: {
+			value: COORDINATE_ERROR_MESSAGES.INVALID,
+			isValid: false
+		}
+	};
+}
+/**
+* Validate coordinate value
+* @internal
+*/
+function isValidCoordinateValue(value) {
+	return value !== null && typeof value.lat === "number" && typeof value.lon === "number";
+}
+/**
+* Check if error is due to geographic limitation (poles)
+* @internal
+*/
+function isGeographicLimitationError(error) {
+	const errorMessage = error instanceof Error ? error.message : String(error);
+	return errorMessage.includes("outside UTM limits") || errorMessage.includes("invalid UTM zone");
+}
+/**
+* Convert coordinate to a specific format with error handling
+* @internal
+*/
+function convertToFormat(coord, format, value) {
+	try {
+		let formattedValue;
+		switch (format) {
+			case "dd":
+				formattedValue = coord.dd();
+				break;
+			case "ddm":
+				formattedValue = coord.ddm();
+				break;
+			case "dms":
+				formattedValue = coord.dms();
+				break;
+			case "mgrs":
+				formattedValue = coord.mgrs();
+				break;
+			case "utm":
+				formattedValue = coord.utm();
+				break;
+			default: return {
+				value: COORDINATE_ERROR_MESSAGES.INVALID,
+				isValid: false
+			};
+		}
+		return {
+			value: formattedValue,
+			isValid: true
+		};
+	} catch (error) {
+		if ((format === "mgrs" || format === "utm") && isGeographicLimitationError(error)) return {
+			value: COORDINATE_ERROR_MESSAGES.NOT_AVAILABLE_AT_POLES,
+			isValid: false
+		};
+		logger.withContext({ value: JSON.stringify(value) }).withError(error).error(`Failed to convert to ${format}`);
+		return {
+			value: COORDINATE_ERROR_MESSAGES.CONVERSION_FAILED,
+			isValid: false
+		};
+	}
+}
+/**
+* Get all coordinate formats for a given DD value
+*
+* Converts a Decimal Degrees coordinate to all 5 supported coordinate systems
+* for display in the format conversion popover.
+*
+* Each format is tried independently - if one fails (e.g., UTM/MGRS at poles),
+* the others can still succeed.
+*
+* @param value - Coordinate value in DD format `{ lat: number, lon: number }`
+* @returns Object containing formatted strings and validity status for all coordinate systems
+*
+* @example
+* const formats = getAllCoordinateFormats({ lat: 40.7128, lon: -74.0060 });
+* // Returns: {
+* //   dd: { value: "40.7128 N / 74.006 W", isValid: true },
+* //   ddm: { value: "40 42.768 N / 74 0.36 W", isValid: true },
+* //   dms: { value: "40 42 46.08 N / 74 0 21.6 W", isValid: true },
+* //   mgrs: { value: "18T WL 80654 06346", isValid: true },
+* //   utm: { value: "18N 585628 4511644", isValid: true }
+* // }
+*
+* @example
+* const formats = getAllCoordinateFormats({ lat: 90, lon: 0 });
+* // Returns: {
+* //   dd: { value: "90 N / 0 E", isValid: true },
+* //   ddm: { value: "90 0 N / 0 0 E", isValid: true },
+* //   dms: { value: "90 0 0 N / 0 0 0 E", isValid: true },
+* //   mgrs: { value: "Not available at poles", isValid: false },
+* //   utm: { value: "Not available at poles", isValid: false }
+* // }
+*/
+function getAllCoordinateFormats(value) {
+	const invalidResult = createInvalidResult();
+	if (!isValidCoordinateValue(value)) return invalidResult;
+	const validValue = value;
+	try {
+		const coord = createCoordinate(coordinateSystems.dd, "LATLON")(`${validValue.lat} / ${validValue.lon}`);
+		if (!coord.valid) return invalidResult;
+		const result = {};
+		for (const format of COORDINATE_SYSTEMS) result[format] = convertToFormat(coord, format, validValue);
+		return result;
+	} catch (error) {
+		logger.withContext({ value: JSON.stringify(validValue) }).withError(error).error("Failed to get all coordinate formats");
+		return invalidResult;
+	}
+}
+/**
+* Check if pasted text looks like a complete coordinate string
+*
+* Uses heuristics to detect if the pasted text contains a full coordinate
+* rather than just a single segment value. This prevents intercepting
+* single-segment pastes.
+*
+* Indicators of a complete coordinate:
+* - Contains separators: comma, slash, or multiple consecutive spaces
+* - Contains coordinate symbols: °, ′, ″, ', "
+* - Multiple numbers separated by whitespace
+*
+* @param text - The pasted text to check
+* @returns True if it looks like a complete coordinate string
+*
+* @example
+* isCompleteCoordinate("40.7128, -74.0060") // true - contains comma
+* isCompleteCoordinate("40° 42' 46\" N / 74° 0' 22\" W") // true - contains symbols
+* isCompleteCoordinate("18T WM 12345 67890") // true - multiple parts
+* isCompleteCoordinate("42") // false - single number
+* isCompleteCoordinate("N") // false - single letter
+*/
+function isCompleteCoordinate(text) {
+	if (!text || text.trim() === "") return false;
+	const hasSeparators = /[,/]|°|′|″|['"]|\s{2,}/.test(text);
+	const hasMultipleNumbers = (text.match(/\d+/g) || []).length >= 2;
+	const isMGRS = /^\d{1,2}[A-Z]\s+[A-Z]{2}\s+\d+\s+\d+$/i.test(text.trim());
+	const isUTM = /^\d{1,2}[NS]\s+\d+\s+\d+$/i.test(text.trim());
+	return hasSeparators || hasMultipleNumbers || isMGRS || isUTM;
+}
+/**
+* Attempt to parse pasted text as all coordinate formats
+*
+* Tries to parse the pasted text using each of the 5 coordinate system parsers.
+* Returns all formats that successfully parse the text.
+*
+* This enables automatic detection of coordinate format and disambiguation
+* when multiple formats match the same input string.
+*
+* @param pastedText - The raw text from clipboard
+* @returns Array of successfully parsed coordinate matches (may be empty)
+*
+* @example
+* const matches = parseCoordinatePaste("40.7128, -74.0060");
+* // Returns: [{ format: 'dd', value: { lat: 40.7128, lon: -74.0060 }, displayString: "..." }]
+*
+* @example
+* const matches = parseCoordinatePaste("18T WM 12345 67890");
+* // Returns: [{ format: 'mgrs', value: { lat: ..., lon: ... }, displayString: "..." }]
+*
+* @example
+* const matches = parseCoordinatePaste("invalid text");
+* // Returns: []
+*/
+function parseCoordinatePaste(pastedText) {
+	if (!pastedText || pastedText.trim() === "") return [];
+	const matches = [];
+	for (const format of COORDINATE_SYSTEMS) try {
+		const coord = createCoordinate(coordinateSystems[format], "LATLON")(pastedText.trim());
+		if (coord.valid) {
+			const { LAT, LON } = coord.raw;
+			let displayString;
+			switch (format) {
+				case "dd":
+					displayString = coord.dd();
+					break;
+				case "ddm":
+					displayString = coord.ddm();
+					break;
+				case "dms":
+					displayString = coord.dms();
+					break;
+				case "mgrs":
+					displayString = coord.mgrs();
+					break;
+				case "utm":
+					displayString = coord.utm();
+					break;
+				default: displayString = "";
+			}
+			matches.push({
+				format,
+				value: {
+					lat: LAT,
+					lon: LON
+				},
+				displayString
+			});
+		}
+	} catch (error) {
+		logger.withContext({
+			pastedText: pastedText.trim(),
+			format: String(format)
+		}).withError(error).warn(`Failed to parse as ${format}`);
+	}
+	return matches;
+}
+/**
+* Check if two coordinates are equal within epsilon tolerance
+*/
+function areCoordinatesEqual(coord1, coord2, epsilon = COORDINATE_EPSILON) {
+	return Math.abs(coord1.lat - coord2.lat) < epsilon && Math.abs(coord1.lon - coord2.lon) < epsilon;
+}
+/**
+* Deduplicate coordinate matches by location, keeping first match for each unique location
+*/
+function deduplicateMatchesByLocation(matches) {
+	const uniqueMatches = [];
+	for (const match of matches) if (!uniqueMatches.some((existing) => areCoordinatesEqual(existing.value, match.value))) uniqueMatches.push(match);
+	return uniqueMatches;
+}
+
+//#endregion
+export { COORDINATE_EPSILON, COORDINATE_ERROR_MESSAGES, areAllSegmentsFilled, areCoordinatesEqual, convertDDToDisplaySegments, convertDisplaySegmentsToDD, deduplicateMatchesByLocation, formatSegmentsToCoordinateString, getAllCoordinateFormats, hasAnySegmentValue, isCompleteCoordinate, parseCoordinatePaste, parseCoordinateStringToSegments, validateCoordinateSegments };
 //# sourceMappingURL=coordinate-utils.js.map