@accelint/geo 0.6.1 → 0.7.0

package/CHANGELOG.md

@@ -1,5 +1,25 @@
 # @accelint/geo
 
+## 0.7.0
+
+### Minor Changes
+
+- dcaba41: Add a coordinate "parts" API that returns the structured pieces of a formatted coordinate instead of only a finished string. `toDecimalDegreesParts(value, axis, precision?)`, `toDdmParts(value, axis, precision?)`, and `toDmsParts(value, axis, precision?)` take a signed number plus its axis and return the non-negative `degrees`/`minutes`/`seconds` numbers and the `hemisphere` letter (`'N' | 'S' | 'E' | 'W'`), with the `60″ → +1′ → +1°` and `60′ → +1°` carry already applied. `toMgrsParts([lat, lon])` and `toUtmParts([lat, lon])` read the grid fields directly and return a discriminated result — `{ ok: true, value: … }` for in-band coordinates or `{ ok: false, reason: 'out-of-range' }` for latitudes outside the inclusive `80°S`–`84°N` band, and for a longitude of exactly `+180°` (the antimeridian, where the UTM zone is undefined) — so callers can branch on validity without matching thrown error text, and never have to guard against a thrown exception. The result stays total even when `geodesy` itself rejects a coordinate (for example an unpatched `geodesy@2.4.0` at the 84°N edge): that also maps to `{ ok: false }`. The supporting types (`DecimalDegreesParts`, `DdmParts`, `DmsParts`, `MgrsParts`, `UtmParts`, `GridPartsResult`) are exported alongside them.
+
+  `formatMgrsParts(MgrsParts)` and `formatUtmParts(UtmParts)` render grid parts back into their canonical strings, so callers that already hold parts (or want to consume `toMgrsParts`/`toUtmParts` and render without re-deriving the pad/floor/join logic) share one renderer instead of duplicating it. The boolean `isValidNumericCoordinate(lat, lon)` predicate is also exported for callers that need a finite-and-in-range check without the error-message array `validateNumericCoordinate` builds.
+
+  The existing `format*`/`parse*` functions and `createCoordinate(...).mgrs()`/`.utm()` now compose over this parts layer internally; their string output is byte-identical to before.
+
+  Also newly exported, since the parts layer is built from them: `getHemisphere(value, axis)` with the `Axis` and `Hemisphere` types (the typed core behind the existing `getOrdinal`); the grid-band helpers `isWithinGridBand(lat)`, `isOnEasternAntimeridian(lon)`, and `isGridProjectable([lat, lon])` with the `GRID_LATITUDE_MIN` / `GRID_LATITUDE_MAX` bounds; the display-precision defaults `DECIMAL_DEGREES_PRECISION`, `DDM_PRECISION`, and `DMS_PRECISION`; and `formatCoordinateSystem`, the lossless round-trip scaffold the `CoordinateSystem` `toFormat` implementations share (distinct from the display formatters — it applies no rounding or carry).
+
+### Patch Changes
+
+- 747ea86: Export `formatCoordinate` and `normalizeLongitude` from `@accelint/map-toolkit/cursor-coordinates`. `formatCoordinate(lonLat, format)` is the pure formatter behind `useCursorCoordinates` — reach for it to render a DD/DDM/DMS/MGRS/UTM string outside the hook instead of re-deriving the grid-conversion logic.
+
+  Also stop a `RangeError` escaping `formatCoordinate` at the UTM/MGRS latitude boundaries (84°N and 80°S). Both are valid in those systems, but `geodesy@2.4.0` rejected them — 84°N via too-strict northing bounds (widest in the extended Svalbard zones), 80°S via a floating-point error in the latitude-band lookup. Two layers: this monorepo patches `geodesy` (`patches/geodesy@2.4.0.patch`, a workspace-only pnpm patch that does not ship in the published package), and `@accelint/geo`'s grid-parts functions now return `{ ok: false }` instead of throwing whenever geodesy rejects a coordinate — so `formatCoordinate` shows the `--- -- ---- ----` placeholder rather than crashing, even against an unpatched `geodesy`. Coordinates outside the valid band still report `valid: false` as before.
+
+- 9345871: Fix parsing and formatting of coordinate magnitudes below `1e-6°` (within about 11 cm of the equator or prime meridian). JavaScript renders such numbers in exponential notation (`String(0.0000001)` is `'1e-7'`), which the lexer mis-tokenized — the `-7` read as a sign, so `'0.0000001 N / 0 E'` failed with "Bearing (N) conflicts with negative number" — and which `createCoordinate(...).dd()`/`.ddm()`/`.dms()` emitted verbatim. Both paths now use the new `toPlainDecimalString(value)` helper, which renders any number in plain decimal notation; ordinary coordinates are unaffected.
+
 ## 0.6.1
 
 ### Patch Changes

package/README.md

@@ -12,6 +12,8 @@ Geographic coordinate parsing, conversion, and formatting for multiple coordinat
   - Universal Transverse Mercator (UTM): `18N 585628 4511644`
 
 - **Flexible Format Ordering**: Convert between LATLON and LONLAT formats
+- **Structured Parts API**: Get the numeric pieces of a coordinate (`{ degrees, minutes, seconds, hemisphere }`, or grid components) instead of a formatted string — useful for segmented inputs and custom renderers
+- **Standalone Functions**: Per-system `format*`/`parse*` helpers and validation predicates alongside the `createCoordinate` façade
 - **Input Validation**: Detailed error messages for invalid coordinates
 - **Performance Optimized**: Immutable coordinate objects with intelligent caching
 - **Type Safe**: Full TypeScript support with complete type definitions
@@ -19,7 +21,7 @@ Geographic coordinate parsing, conversion, and formatting for multiple coordinat
 ## Installation
 
 ```sh
-npm install @accelint/geo
+pnpm add @accelint/geo
 ```
 
 ## Quick Start
@@ -207,6 +209,101 @@ const latlon: LatLonTuple = [40.7128, -74.0060]; // [latitude, longitude]
 const lonlat: LonLatTuple = [-74.0060, 40.7128]; // [longitude, latitude]
 ```
 
+## Structured Parts API
+
+When you need the numeric components of a coordinate rather than a formatted string — driving segmented inputs, building a custom renderer, or feeding another calculation — reach for the parts functions instead of parsing a formatted string back apart.
+
+### Lat/lon parts
+
+`toDecimalDegreesParts`, `toDdmParts`, and `toDmsParts` each take a single signed value plus an axis (`'lat'` or `'lon'`) and return the non-negative magnitude components plus a `hemisphere` letter. Carry is applied so `minutes` and `seconds` never reach `60`.
+
+```typescript
+import { toDecimalDegreesParts, toDdmParts, toDmsParts } from '@accelint/geo';
+
+toDecimalDegreesParts(-122.4194, 'lon');
+// { degrees: 122.4194, hemisphere: 'W' }
+
+toDdmParts(12.576, 'lat');
+// { degrees: 12, minutes: 34.56, hemisphere: 'N' }
+
+toDmsParts(-77.0369, 'lon');
+// { degrees: 77, minutes: 2, seconds: 12.84, hemisphere: 'W' }
+```
+
+Each accepts an optional trailing `precision` argument (defaults: DD `6`, DDM `4`, DMS `2`).
+
+### Grid parts
+
+`toUtmParts` and `toMgrsParts` take a signed `[latitude, longitude]` tuple and read the grid components directly. They return a discriminated `GridPartsResult`: `{ ok: true, value }` on success, or `{ ok: false, reason: 'out-of-range' }` when the coordinate is non-finite, outside the inclusive `80°S`–`84°N` grid band, or exactly `+180°` longitude (where the UTM zone is undefined). They never throw, so callers branch on `ok` instead of catching an error.
+
+```typescript
+import { toUtmParts, toMgrsParts, formatUtmParts, formatMgrsParts } from '@accelint/geo';
+
+toUtmParts([38.8977, -77.0365]);
+// { ok: true, value: { zone: 18, hemisphere: 'N', easting: 323394, northing: 4307396 } }
+
+toUtmParts([85, 0]);
+// { ok: false, reason: 'out-of-range' }
+
+toMgrsParts([-81, 0]);
+// { ok: false, reason: 'out-of-range' }
+```
+
+`formatUtmParts` / `formatMgrsParts` render grid parts back into the canonical string, so a caller that already holds parts (or wants to consume `toUtmParts`/`toMgrsParts` and render) shares one renderer:
+
+```typescript
+formatUtmParts({ zone: 18, hemisphere: 'N', easting: 323394, northing: 4307396 });
+// '18N 323394 4307396'
+```
+
+### Helpers
+
+The pieces the parts layer is built from are exported too:
+
+- `getHemisphere(value, axis)` returns the typed `'N' | 'S' | 'E' | 'W'` letter for a signed value on `'lat'` or `'lon'` (`0` maps to `N`/`E`). `Axis` and `Hemisphere` are the matching types; `getOrdinal` is the older boolean-axis form of the same function.
+- `isWithinGridBand(lat)`, `isOnEasternAntimeridian(lon)`, and `isGridProjectable([lat, lon])` are the checks behind `toUtmParts`/`toMgrsParts`, with the band edges exported as `GRID_LATITUDE_MIN` (`-80`) and `GRID_LATITUDE_MAX` (`84`).
+- `DECIMAL_DEGREES_PRECISION` (`6`), `DDM_PRECISION` (`4`), and `DMS_PRECISION` (`2`) are the parts functions' default precisions.
+- `toPlainDecimalString(value)` renders a number in plain decimal notation. JavaScript switches to exponential notation below `1e-6` (`String(0.0000001)` is `'1e-7'`); use this when building a coordinate string by hand from very small magnitudes.
+
+```typescript
+import { getHemisphere, isGridProjectable, toPlainDecimalString } from '@accelint/geo';
+
+getHemisphere(-77.0369, 'lon');    // 'W'
+isGridProjectable([85, 0]);        // false
+toPlainDecimalString(0.0000001);   // '0.0000001'
+```
+
+## Standalone Functions
+
+The per-system `format*` and `parse*` functions are exported directly, so you can format a `[latitude, longitude]` tuple (or parse a single system's string) without building a `createCoordinate` object.
+
+```typescript
+import { formatDecimalDegrees, formatDegreesMinutesSeconds } from '@accelint/geo';
+
+formatDecimalDegrees([37.7749, -122.4194], { separator: ' / ', withOrdinal: true });
+// '37.774900° N / 122.419400° W'
+
+formatDegreesMinutesSeconds([37.7749, -122.4194], { separator: ' / ' });
+// '37° 46' 29.64″ / 122° 25' 9.84″'
+```
+
+Parsers: `parseDecimalDegrees`, `parseDegreesDecimalMinutes`, `parseDegreesMinutesSeconds`, `parseMGRS`, and `parseUTM` parse a single system's string.
+
+### Validation
+
+`isValidNumericCoordinate` is a boolean check (finite and in range); `validateNumericCoordinate` returns an array of error messages (empty when valid).
+
+```typescript
+import { isValidNumericCoordinate, validateNumericCoordinate } from '@accelint/geo';
+
+isValidNumericCoordinate(45.5, -122.6); // true
+isValidNumericCoordinate(91, -122.6);   // false
+
+validateNumericCoordinate(45.5, -122.6); // []
+validateNumericCoordinate(91, -122.6);
+// ['[ERROR] Latitude value (91) is outside valid range (-90 to 90).']
+```
+
 ## Coordinate System Formats
 
 ### Decimal Degrees (DD)

package/catalog-info.yaml

@@ -15,7 +15,7 @@ metadata:
   annotations:
     backstage.io/edit-url: https://github.com/gohypergiant/standard-toolkit/blob/main/packages/geo/catalog-info.yaml
     backstage.io/techdocs-ref: dir:.
-    package/version: 0.6.1
+    package/version: 0.7.0
     github.com/project-slug: gohypergiant/standard-toolkit
   links:
     - url: https://github.com/gohypergiant/standard-toolkit/tree/main/packages/geo

package/dist/coordinates/latlon/decimal-degrees/formatter.d.ts

@@ -11,9 +11,42 @@
  */
 
 import { FormatOptions } from "../internal/format.js";
+import { Axis, Hemisphere } from "../internal/ordinal.js";
 
 //#region src/coordinates/latlon/decimal-degrees/formatter.d.ts
-
+/** Default number of decimal places for decimal-degrees formatting. */
+declare const DECIMAL_DEGREES_PRECISION = 6;
+/**
+ * Structured decimal-degrees parts for a single signed coordinate value.
+ *
+ * `degrees` is the non-negative magnitude rounded to the requested precision;
+ * the signed value is recoverable from the axis and `hemisphere`.
+ */
+type DecimalDegreesParts = {
+  degrees: number;
+  hemisphere: Hemisphere;
+};
+/**
+ * Converts a single signed coordinate value into decimal-degrees parts.
+ *
+ * Returns the non-negative magnitude plus the hemisphere letter for the axis
+ * (following geo's `>= 0` convention). Decimal degrees has no minutes/seconds
+ * carry; the magnitude is simply rounded to the requested precision.
+ *
+ * @param value - The signed coordinate value.
+ * @param axis - Whether the value is a latitude (`'lat'`) or longitude (`'lon'`).
+ * @param precision - Decimal places for the magnitude (default `6`).
+ * @returns The `{ degrees, hemisphere }` parts object.
+ *
+ * @remarks pure function
+ *
+ * @example
+ * ```typescript
+ * toDecimalDegreesParts(-122.4194, 'lon');
+ * // { degrees: 122.4194, hemisphere: 'W' }
+ * ```
+ */
+declare const toDecimalDegreesParts: (value: number, axis: Axis, precision?: number) => DecimalDegreesParts;
 /**
  * Formats latitude/longitude coordinates in decimal degrees notation.
  *
@@ -35,5 +68,5 @@ import { FormatOptions } from "../internal/format.js";
  */
 declare const formatDecimalDegrees: (coordinates: [number, number], config?: FormatOptions) => string;
 //#endregion
-export { formatDecimalDegrees };
+export { DECIMAL_DEGREES_PRECISION, DecimalDegreesParts, formatDecimalDegrees, toDecimalDegreesParts };
 //# sourceMappingURL=formatter.d.ts.map

package/dist/coordinates/latlon/decimal-degrees/formatter.js

@@ -11,13 +11,42 @@
  */
 
 
+import { getHemisphere } from "../internal/ordinal.js";
 import { createFormatter } from "../internal/format.js";
 
 //#region src/coordinates/latlon/decimal-degrees/formatter.ts
+/** Default number of decimal places for decimal-degrees formatting. */
+const DECIMAL_DEGREES_PRECISION = 6;
+/**
+* Converts a single signed coordinate value into decimal-degrees parts.
+*
+* Returns the non-negative magnitude plus the hemisphere letter for the axis
+* (following geo's `>= 0` convention). Decimal degrees has no minutes/seconds
+* carry; the magnitude is simply rounded to the requested precision.
+*
+* @param value - The signed coordinate value.
+* @param axis - Whether the value is a latitude (`'lat'`) or longitude (`'lon'`).
+* @param precision - Decimal places for the magnitude (default `6`).
+* @returns The `{ degrees, hemisphere }` parts object.
+*
+* @remarks pure function
+*
+* @example
+* ```typescript
+* toDecimalDegreesParts(-122.4194, 'lon');
+* // { degrees: 122.4194, hemisphere: 'W' }
+* ```
+*/
+const toDecimalDegreesParts = (value, axis, precision = DECIMAL_DEGREES_PRECISION) => {
+	return {
+		degrees: Number(Math.abs(value).toFixed(precision)),
+		hemisphere: getHemisphere(value, axis)
+	};
+};
 /**
 * Converts a coordinate value to decimal degrees format.
 *
-* @param num - The coordinate value to format.
+* @param value - The coordinate value to format.
 * @param withOrdinal - Whether to use absolute value (when ordinal directions are shown separately).
 * @returns Formatted coordinate string with degree symbol and 6 decimal places.
 *
@@ -33,8 +62,8 @@ import { createFormatter } from "../internal/format.js";
 * // '122.419400°'
 * ```
 */
-const toDecimalDegrees = (num, withOrdinal) => {
-	return `${(withOrdinal ? Math.abs(num) : num).toFixed(6)}°`;
+const toDecimalDegrees = (value, withOrdinal) => {
+	return `${(withOrdinal ? Math.abs(value) : value).toFixed(DECIMAL_DEGREES_PRECISION)}°`;
 };
 /**
 * Formats latitude/longitude coordinates in decimal degrees notation.
@@ -58,5 +87,5 @@ const toDecimalDegrees = (num, withOrdinal) => {
 const formatDecimalDegrees = createFormatter(toDecimalDegrees);
 
 //#endregion
-export { formatDecimalDegrees };
+export { DECIMAL_DEGREES_PRECISION, formatDecimalDegrees, toDecimalDegreesParts };
 //# sourceMappingURL=formatter.js.map

package/dist/coordinates/latlon/decimal-degrees/formatter.js.map

@@ -1 +1 @@
-{"version":3,"file":"formatter.js","names":[],"sources":["../../../../src/coordinates/latlon/decimal-degrees/formatter.ts"],"sourcesContent":["/*\n * Copyright 2026 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport { createFormatter } from '../internal/format';\n\n/**\n * Converts a coordinate value to decimal degrees format.\n *\n * @param num - The coordinate value to format.\n * @param withOrdinal - Whether to use absolute value (when ordinal directions are shown separately).\n * @returns Formatted coordinate string with degree symbol and 6 decimal places.\n *\n * @example\n * ```typescript\n * toDecimalDegrees(45.123456);\n * // '45.123456°'\n * ```\n *\n * @example\n * ```typescript\n * toDecimalDegrees(-122.4194, true);\n * // '122.419400°'\n * ```\n */\nconst toDecimalDegrees = (num: number, withOrdinal?: boolean): string => {\n  const value = withOrdinal ? Math.abs(num) : num;\n  return `${value.toFixed(6)}°`;\n};\n\n/**\n * Formats latitude/longitude coordinates in decimal degrees notation.\n *\n * @param coordinates - Tuple of [latitude, longitude] values.\n * @param config - Optional formatting configuration.\n * @returns Formatted coordinate string in decimal degrees format.\n *\n * @example\n * ```typescript\n * formatDecimalDegrees([37.7749, -122.4194]);\n * // '37.774900° N, 122.419400° W'\n * ```\n *\n * @example\n * ```typescript\n * formatDecimalDegrees([37.7749, -122.4194], { separator: ' / ' });\n * // '37.774900° N / 122.419400° W'\n * ```\n */\nexport const formatDecimalDegrees = createFormatter(toDecimalDegrees);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAiCA,MAAM,oBAAoB,KAAa,gBAAkC;AAEvE,QAAO,IADO,cAAc,KAAK,IAAI,IAAI,GAAG,KAC5B,QAAQ,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;AAsB7B,MAAa,uBAAuB,gBAAgB,iBAAiB"}
+{"version":3,"file":"formatter.js","names":[],"sources":["../../../../src/coordinates/latlon/decimal-degrees/formatter.ts"],"sourcesContent":["/*\n * Copyright 2026 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport { createFormatter } from '../internal/format';\nimport { type Axis, getHemisphere, type Hemisphere } from '../internal/ordinal';\n\n/** Default number of decimal places for decimal-degrees formatting. */\nexport const DECIMAL_DEGREES_PRECISION = 6;\n\n/**\n * Structured decimal-degrees parts for a single signed coordinate value.\n *\n * `degrees` is the non-negative magnitude rounded to the requested precision;\n * the signed value is recoverable from the axis and `hemisphere`.\n */\nexport type DecimalDegreesParts = {\n  degrees: number;\n  hemisphere: Hemisphere;\n};\n\n/**\n * Converts a single signed coordinate value into decimal-degrees parts.\n *\n * Returns the non-negative magnitude plus the hemisphere letter for the axis\n * (following geo's `>= 0` convention). Decimal degrees has no minutes/seconds\n * carry; the magnitude is simply rounded to the requested precision.\n *\n * @param value - The signed coordinate value.\n * @param axis - Whether the value is a latitude (`'lat'`) or longitude (`'lon'`).\n * @param precision - Decimal places for the magnitude (default `6`).\n * @returns The `{ degrees, hemisphere }` parts object.\n *\n * @remarks pure function\n *\n * @example\n * ```typescript\n * toDecimalDegreesParts(-122.4194, 'lon');\n * // { degrees: 122.4194, hemisphere: 'W' }\n * ```\n */\nexport const toDecimalDegreesParts = (\n  value: number,\n  axis: Axis,\n  precision: number = DECIMAL_DEGREES_PRECISION,\n): DecimalDegreesParts => {\n  const degrees = Number(Math.abs(value).toFixed(precision));\n\n  return {\n    degrees,\n    hemisphere: getHemisphere(value, axis),\n  };\n};\n\n/**\n * Converts a coordinate value to decimal degrees format.\n *\n * @param value - The coordinate value to format.\n * @param withOrdinal - Whether to use absolute value (when ordinal directions are shown separately).\n * @returns Formatted coordinate string with degree symbol and 6 decimal places.\n *\n * @example\n * ```typescript\n * toDecimalDegrees(45.123456);\n * // '45.123456°'\n * ```\n *\n * @example\n * ```typescript\n * toDecimalDegrees(-122.4194, true);\n * // '122.419400°'\n * ```\n */\nconst toDecimalDegrees = (value: number, withOrdinal?: boolean): string => {\n  const rendered = withOrdinal ? Math.abs(value) : value;\n\n  return `${rendered.toFixed(DECIMAL_DEGREES_PRECISION)}°`;\n};\n\n/**\n * Formats latitude/longitude coordinates in decimal degrees notation.\n *\n * @param coordinates - Tuple of [latitude, longitude] values.\n * @param config - Optional formatting configuration.\n * @returns Formatted coordinate string in decimal degrees format.\n *\n * @example\n * ```typescript\n * formatDecimalDegrees([37.7749, -122.4194]);\n * // '37.774900° N, 122.419400° W'\n * ```\n *\n * @example\n * ```typescript\n * formatDecimalDegrees([37.7749, -122.4194], { separator: ' / ' });\n * // '37.774900° N / 122.419400° W'\n * ```\n */\nexport const formatDecimalDegrees = createFormatter(toDecimalDegrees);\n"],"mappings":";;;;;;;;;;;;;;;;;;AAgBA,MAAa,4BAA4B;;;;;;;;;;;;;;;;;;;;;AAiCzC,MAAa,yBACX,OACA,MACA,YAAoB,8BACI;AAGxB,QAAO;EACL,SAHc,OAAO,KAAK,IAAI,MAAM,CAAC,QAAQ,UAAU,CAAC;EAIxD,YAAY,cAAc,OAAO,KAAK;EACvC;;;;;;;;;;;;;;;;;;;;;AAsBH,MAAM,oBAAoB,OAAe,gBAAkC;AAGzE,QAAO,IAFU,cAAc,KAAK,IAAI,MAAM,GAAG,OAE9B,QAAQ,0BAA0B,CAAC;;;;;;;;;;;;;;;;;;;;;AAsBxD,MAAa,uBAAuB,gBAAgB,iBAAiB"}

package/dist/coordinates/latlon/decimal-degrees/system.js

@@ -11,7 +11,9 @@
  */
 
 
-import { BEARINGS, SYMBOLS, SYMBOL_PATTERNS } from "../internal/index.js";
+import { toPlainDecimalString } from "../internal/plain-decimal.js";
+import { SYMBOL_PATTERNS } from "../internal/index.js";
+import { formatCoordinateSystem } from "../internal/format.js";
 import { parseDecimalDegrees } from "./parser.js";
 
 //#region src/coordinates/latlon/decimal-degrees/system.ts
@@ -53,8 +55,8 @@ const systemDecimalDegrees = {
 		const [num, bear] = arg;
 		return Number.parseFloat(num) * (SYMBOL_PATTERNS.NEGATIVE_BEARINGS.test(bear) ? -1 : 1);
 	},
-	toFormat(format, [left, right]) {
-		return [left, right].map((num, index) => `${Math.abs(num)} ${BEARINGS[format][index][+(num < 0)]}`).join(` ${SYMBOLS.DIVIDER} `);
+	toFormat(format, coordinates) {
+		return formatCoordinateSystem(format, coordinates, toPlainDecimalString);
 	}
 };
 

package/dist/coordinates/latlon/decimal-degrees/system.js.map

@@ -1 +1 @@
-{"version":3,"file":"system.js","names":["systemDecimalDegrees: CoordinateSystem"],"sources":["../../../../src/coordinates/latlon/decimal-degrees/system.ts"],"sourcesContent":["// __private-exports\n/*\n * Copyright 2024 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport {\n  BEARINGS,\n  type Compass,\n  type Format,\n  SYMBOL_PATTERNS,\n  SYMBOLS,\n} from '../internal';\nimport { parseDecimalDegrees } from './parser';\nimport type { CoordinateSystem } from '../internal/coordinate-system';\n\n/**\n * Decimal Degrees coordinate system implementation.\n *\n * Provides parsing, conversion, and formatting for coordinates in decimal degrees notation.\n * Coordinates are expressed as decimal numbers with degree symbols (e.g., 37.7749° N).\n *\n * @property name - Human-readable name of the coordinate system.\n * @property parse - Parses decimal degrees coordinate strings.\n * @property toFloat - Converts parsed coordinate components to floating point numbers.\n * @property toFormat - Formats numeric coordinates back to decimal degrees string.\n *\n * @example\n * ```ts\n * // Parse a coordinate string\n * const [coords, errors] = systemDecimalDegrees.parse('37.7749° N / 122.4194° W', 'LATLON');\n * ```\n *\n * @example\n * ```ts\n * // Convert to float\n * const lat = systemDecimalDegrees.toFloat(['37.7749', 'N']);\n * // 37.7749\n * ```\n *\n * @example\n * ```ts\n * // Format to string\n * const formatted = systemDecimalDegrees.toFormat('LATLON', [37.7749, -122.4194]);\n * // '37.7749 N / 122.4194 W'\n * ```\n */\nexport const systemDecimalDegrees: CoordinateSystem = {\n  name: 'Decimal Degrees',\n\n  parse: parseDecimalDegrees,\n\n  toFloat(arg) {\n    const [num, bear] = arg as [string, Compass];\n\n    return (\n      Number.parseFloat(num) *\n      (SYMBOL_PATTERNS.NEGATIVE_BEARINGS.test(bear) ? -1 : 1)\n    );\n  },\n\n  toFormat(format: Format, [left, right]: [number, number]) {\n    return [left, right]\n      .map(\n        (num, index) =>\n          `${Math.abs(num)} ${BEARINGS[format][index as 0 | 1][+(num < 0)]}`,\n      )\n      .join(` ${SYMBOLS.DIVIDER} `);\n  },\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDA,MAAaA,uBAAyC;CACpD,MAAM;CAEN,OAAO;CAEP,QAAQ,KAAK;EACX,MAAM,CAAC,KAAK,QAAQ;AAEpB,SACE,OAAO,WAAW,IAAI,IACrB,gBAAgB,kBAAkB,KAAK,KAAK,GAAG,KAAK;;CAIzD,SAAS,QAAgB,CAAC,MAAM,QAA0B;AACxD,SAAO,CAAC,MAAM,MAAM,CACjB,KACE,KAAK,UACJ,GAAG,KAAK,IAAI,IAAI,CAAC,GAAG,SAAS,QAAQ,OAAgB,EAAE,MAAM,MAChE,CACA,KAAK,IAAI,QAAQ,QAAQ,GAAG;;CAElC"}
+{"version":3,"file":"system.js","names":["systemDecimalDegrees: CoordinateSystem"],"sources":["../../../../src/coordinates/latlon/decimal-degrees/system.ts"],"sourcesContent":["// __private-exports\n/*\n * Copyright 2024 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport { type Compass, type Format, SYMBOL_PATTERNS } from '../internal';\nimport { formatCoordinateSystem } from '../internal/format';\nimport { toPlainDecimalString } from '../internal/plain-decimal';\nimport { parseDecimalDegrees } from './parser';\nimport type { CoordinateSystem } from '../internal/coordinate-system';\n\n/**\n * Decimal Degrees coordinate system implementation.\n *\n * Provides parsing, conversion, and formatting for coordinates in decimal degrees notation.\n * Coordinates are expressed as decimal numbers with degree symbols (e.g., 37.7749° N).\n *\n * @property name - Human-readable name of the coordinate system.\n * @property parse - Parses decimal degrees coordinate strings.\n * @property toFloat - Converts parsed coordinate components to floating point numbers.\n * @property toFormat - Formats numeric coordinates back to decimal degrees string.\n *\n * @example\n * ```ts\n * // Parse a coordinate string\n * const [coords, errors] = systemDecimalDegrees.parse('37.7749° N / 122.4194° W', 'LATLON');\n * ```\n *\n * @example\n * ```ts\n * // Convert to float\n * const lat = systemDecimalDegrees.toFloat(['37.7749', 'N']);\n * // 37.7749\n * ```\n *\n * @example\n * ```ts\n * // Format to string\n * const formatted = systemDecimalDegrees.toFormat('LATLON', [37.7749, -122.4194]);\n * // '37.7749 N / 122.4194 W'\n * ```\n */\nexport const systemDecimalDegrees: CoordinateSystem = {\n  name: 'Decimal Degrees',\n\n  parse: parseDecimalDegrees,\n\n  toFloat(arg) {\n    const [num, bear] = arg as [string, Compass];\n\n    return (\n      Number.parseFloat(num) *\n      (SYMBOL_PATTERNS.NEGATIVE_BEARINGS.test(bear) ? -1 : 1)\n    );\n  },\n\n  toFormat(format: Format, coordinates: [number, number]) {\n    return formatCoordinateSystem(format, coordinates, toPlainDecimalString);\n  },\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDA,MAAaA,uBAAyC;CACpD,MAAM;CAEN,OAAO;CAEP,QAAQ,KAAK;EACX,MAAM,CAAC,KAAK,QAAQ;AAEpB,SACE,OAAO,WAAW,IAAI,IACrB,gBAAgB,kBAAkB,KAAK,KAAK,GAAG,KAAK;;CAIzD,SAAS,QAAgB,aAA+B;AACtD,SAAO,uBAAuB,QAAQ,aAAa,qBAAqB;;CAE3E"}

package/dist/coordinates/latlon/degrees-decimal-minutes/formatter.d.ts

@@ -11,9 +11,49 @@
  */
 
 import { FormatOptions } from "../internal/format.js";
+import { Axis, Hemisphere } from "../internal/ordinal.js";
 
 //#region src/coordinates/latlon/degrees-decimal-minutes/formatter.d.ts
-
+/** Default number of decimal places for degrees-decimal-minutes formatting. */
+declare const DDM_PRECISION = 4;
+/**
+ * Structured degrees-decimal-minutes parts for a single signed coordinate value.
+ *
+ * `degrees` and `minutes` are non-negative; carry keeps `minutes` below `60`.
+ * The signed value is recoverable from the axis and `hemisphere`.
+ */
+type DdmParts = {
+  degrees: number;
+  minutes: number;
+  hemisphere: Hemisphere;
+};
+/**
+ * Converts a single signed coordinate value into degrees-decimal-minutes parts.
+ *
+ * Applies the minutes carry (`60′ → +1°`) after rounding so `minutes` never
+ * reaches `60`, then attaches the hemisphere letter for the axis.
+ *
+ * This is the display path: it rounds to `precision` and carries. The
+ * lossless round-trip representation returned by `createCoordinate(...).ddm()`
+ * lives separately in `degrees-decimal-minutes/system.ts` (`toFormat`, via the
+ * shared `formatCoordinateSystem`), which keeps full precision and applies no
+ * carry so a value survives format → parse unchanged. The two are
+ * intentionally not shared — do not route one through the other.
+ *
+ * @param value - The signed coordinate value.
+ * @param axis - Whether the value is a latitude (`'lat'`) or longitude (`'lon'`).
+ * @param precision - Decimal places for the minutes (default `4`).
+ * @returns The `{ degrees, minutes, hemisphere }` parts object.
+ *
+ * @remarks pure function
+ *
+ * @example
+ * ```typescript
+ * toDdmParts(12.576, 'lat');
+ * // { degrees: 12, minutes: 34.56, hemisphere: 'N' }
+ * ```
+ */
+declare const toDdmParts: (value: number, axis: Axis, precision?: number) => DdmParts;
 /**
  * Formats latitude/longitude coordinates in degrees decimal minutes notation.
  *
@@ -35,5 +75,5 @@ import { FormatOptions } from "../internal/format.js";
  */
 declare const formatDegreesDecimalMinutes: (coordinates: [number, number], config?: FormatOptions) => string;
 //#endregion
-export { formatDegreesDecimalMinutes };
+export { DDM_PRECISION, DdmParts, formatDegreesDecimalMinutes, toDdmParts };
 //# sourceMappingURL=formatter.d.ts.map

package/dist/coordinates/latlon/degrees-decimal-minutes/formatter.js

@@ -11,13 +11,68 @@
  */
 
 
+import { getHemisphere } from "../internal/ordinal.js";
 import { createFormatter } from "../internal/format.js";
 
 //#region src/coordinates/latlon/degrees-decimal-minutes/formatter.ts
+/** Default number of decimal places for degrees-decimal-minutes formatting. */
+const DDM_PRECISION = 4;
+/**
+* Splits a non-negative magnitude into whole degrees and decimal minutes,
+* rounding the minutes to `precision` and carrying `60′ → +1°` so the output
+* stays a valid coordinate. Shared core of {@link toDdmParts} and the display
+* string formatter.
+*
+* @param magnitude - Non-negative coordinate magnitude in degrees.
+* @param precision - Decimal places for the minutes.
+* @returns The `{ degrees, minutes }` pair.
+*
+* @remarks pure function
+*/
+const toDdmMagnitude = (magnitude, precision) => {
+	let degrees = Math.floor(magnitude);
+	let minutes = Number(((magnitude - degrees) * 60).toFixed(precision));
+	degrees += Math.floor(minutes / 60);
+	minutes %= 60;
+	return {
+		degrees,
+		minutes
+	};
+};
+/**
+* Converts a single signed coordinate value into degrees-decimal-minutes parts.
+*
+* Applies the minutes carry (`60′ → +1°`) after rounding so `minutes` never
+* reaches `60`, then attaches the hemisphere letter for the axis.
+*
+* This is the display path: it rounds to `precision` and carries. The
+* lossless round-trip representation returned by `createCoordinate(...).ddm()`
+* lives separately in `degrees-decimal-minutes/system.ts` (`toFormat`, via the
+* shared `formatCoordinateSystem`), which keeps full precision and applies no
+* carry so a value survives format → parse unchanged. The two are
+* intentionally not shared — do not route one through the other.
+*
+* @param value - The signed coordinate value.
+* @param axis - Whether the value is a latitude (`'lat'`) or longitude (`'lon'`).
+* @param precision - Decimal places for the minutes (default `4`).
+* @returns The `{ degrees, minutes, hemisphere }` parts object.
+*
+* @remarks pure function
+*
+* @example
+* ```typescript
+* toDdmParts(12.576, 'lat');
+* // { degrees: 12, minutes: 34.56, hemisphere: 'N' }
+* ```
+*/
+const toDdmParts = (value, axis, precision = DDM_PRECISION) => ({
+	...toDdmMagnitude(Math.abs(value), precision),
+	hemisphere: getHemisphere(value, axis)
+});
 /**
 * Converts a coordinate value to degrees decimal minutes format.
 *
-* @param num - The coordinate value to format.
+* @param value - The coordinate value to format.
 * @returns Formatted coordinate string with degrees and decimal minutes (e.g., "45° 30.1234'").
 *
 * @example
@@ -32,12 +87,9 @@ import { createFormatter } from "../internal/format.js";
 * // '122° 25.1640''
 * ```
 */
-const toDegreesDecimalMinutes = (num) => {
-	let degrees = Math.floor(Math.abs(num));
-	let minutes = Number(((Math.abs(num) - degrees) * 60).toFixed(4));
-	degrees += Math.floor(minutes / 60);
-	minutes %= 60;
-	return `${degrees}° ${minutes.toFixed(4)}'`;
+const toDegreesDecimalMinutes = (value) => {
+	const { degrees, minutes } = toDdmMagnitude(Math.abs(value), DDM_PRECISION);
+	return `${degrees}° ${minutes.toFixed(DDM_PRECISION)}'`;
 };
 /**
 * Formats latitude/longitude coordinates in degrees decimal minutes notation.
@@ -61,5 +113,5 @@ const toDegreesDecimalMinutes = (num) => {
 const formatDegreesDecimalMinutes = createFormatter(toDegreesDecimalMinutes);
 
 //#endregion
-export { formatDegreesDecimalMinutes };
+export { DDM_PRECISION, formatDegreesDecimalMinutes, toDdmParts };
 //# sourceMappingURL=formatter.js.map

package/dist/coordinates/latlon/degrees-decimal-minutes/formatter.js.map

@@ -1 +1 @@
-{"version":3,"file":"formatter.js","names":[],"sources":["../../../../src/coordinates/latlon/degrees-decimal-minutes/formatter.ts"],"sourcesContent":["/*\n * Copyright 2026 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport { createFormatter } from '../internal/format';\n\n/**\n * Converts a coordinate value to degrees decimal minutes format.\n *\n * @param num - The coordinate value to format.\n * @returns Formatted coordinate string with degrees and decimal minutes (e.g., \"45° 30.1234'\").\n *\n * @example\n * ```typescript\n * toDegreesDecimalMinutes(45.5);\n * // '45° 30.0000''\n * ```\n *\n * @example\n * ```typescript\n * toDegreesDecimalMinutes(-122.4194);\n * // '122° 25.1640''\n * ```\n */\nconst toDegreesDecimalMinutes = (num: number): string => {\n  let degrees = Math.floor(Math.abs(num));\n  let minutes = Number(((Math.abs(num) - degrees) * 60).toFixed(4));\n\n  // Rounding can produce 60 minutes (e.g. 40.9999995 -> 40° 60.0000');\n  // carry into degrees so the output stays a valid coordinate.\n  degrees += Math.floor(minutes / 60);\n  minutes %= 60;\n\n  return `${degrees}° ${minutes.toFixed(4)}'`;\n};\n\n/**\n * Formats latitude/longitude coordinates in degrees decimal minutes notation.\n *\n * @param coordinates - Tuple of [latitude, longitude] values.\n * @param config - Optional formatting configuration.\n * @returns Formatted coordinate string in degrees decimal minutes format.\n *\n * @example\n * ```typescript\n * formatDegreesDecimalMinutes([37.7749, -122.4194]);\n * // '37° 46.4940' N, 122° 25.1640' W'\n * ```\n *\n * @example\n * ```typescript\n * formatDegreesDecimalMinutes([37.7749, -122.4194], { separator: ' / ' });\n * // '37° 46.4940' N / 122° 25.1640' W'\n * ```\n */\nexport const formatDegreesDecimalMinutes = createFormatter(\n  toDegreesDecimalMinutes,\n);\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAgCA,MAAM,2BAA2B,QAAwB;CACvD,IAAI,UAAU,KAAK,MAAM,KAAK,IAAI,IAAI,CAAC;CACvC,IAAI,UAAU,SAAS,KAAK,IAAI,IAAI,GAAG,WAAW,IAAI,QAAQ,EAAE,CAAC;AAIjE,YAAW,KAAK,MAAM,UAAU,GAAG;AACnC,YAAW;AAEX,QAAO,GAAG,QAAQ,IAAI,QAAQ,QAAQ,EAAE,CAAC;;;;;;;;;;;;;;;;;;;;;AAsB3C,MAAa,8BAA8B,gBACzC,wBACD"}
+{"version":3,"file":"formatter.js","names":[],"sources":["../../../../src/coordinates/latlon/degrees-decimal-minutes/formatter.ts"],"sourcesContent":["/*\n * Copyright 2026 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport { createFormatter } from '../internal/format';\nimport { type Axis, getHemisphere, type Hemisphere } from '../internal/ordinal';\n\n/** Default number of decimal places for degrees-decimal-minutes formatting. */\nexport const DDM_PRECISION = 4;\n\n/**\n * Structured degrees-decimal-minutes parts for a single signed coordinate value.\n *\n * `degrees` and `minutes` are non-negative; carry keeps `minutes` below `60`.\n * The signed value is recoverable from the axis and `hemisphere`.\n */\nexport type DdmParts = {\n  degrees: number;\n  minutes: number;\n  hemisphere: Hemisphere;\n};\n\n/**\n * Splits a non-negative magnitude into whole degrees and decimal minutes,\n * rounding the minutes to `precision` and carrying `60′ → +1°` so the output\n * stays a valid coordinate. Shared core of {@link toDdmParts} and the display\n * string formatter.\n *\n * @param magnitude - Non-negative coordinate magnitude in degrees.\n * @param precision - Decimal places for the minutes.\n * @returns The `{ degrees, minutes }` pair.\n *\n * @remarks pure function\n */\nconst toDdmMagnitude = (\n  magnitude: number,\n  precision: number,\n): Pick<DdmParts, 'degrees' | 'minutes'> => {\n  let degrees = Math.floor(magnitude);\n  let minutes = Number(((magnitude - degrees) * 60).toFixed(precision));\n\n  // Rounding can produce 60 minutes (e.g. 40.9999995 -> 40° 60.0000');\n  // carry into degrees so the output stays a valid coordinate.\n  degrees += Math.floor(minutes / 60);\n  minutes %= 60;\n\n  return { degrees, minutes };\n};\n\n/**\n * Converts a single signed coordinate value into degrees-decimal-minutes parts.\n *\n * Applies the minutes carry (`60′ → +1°`) after rounding so `minutes` never\n * reaches `60`, then attaches the hemisphere letter for the axis.\n *\n * This is the display path: it rounds to `precision` and carries. The\n * lossless round-trip representation returned by `createCoordinate(...).ddm()`\n * lives separately in `degrees-decimal-minutes/system.ts` (`toFormat`, via the\n * shared `formatCoordinateSystem`), which keeps full precision and applies no\n * carry so a value survives format → parse unchanged. The two are\n * intentionally not shared — do not route one through the other.\n *\n * @param value - The signed coordinate value.\n * @param axis - Whether the value is a latitude (`'lat'`) or longitude (`'lon'`).\n * @param precision - Decimal places for the minutes (default `4`).\n * @returns The `{ degrees, minutes, hemisphere }` parts object.\n *\n * @remarks pure function\n *\n * @example\n * ```typescript\n * toDdmParts(12.576, 'lat');\n * // { degrees: 12, minutes: 34.56, hemisphere: 'N' }\n * ```\n */\nexport const toDdmParts = (\n  value: number,\n  axis: Axis,\n  precision: number = DDM_PRECISION,\n): DdmParts => ({\n  ...toDdmMagnitude(Math.abs(value), precision),\n  hemisphere: getHemisphere(value, axis),\n});\n\n/**\n * Converts a coordinate value to degrees decimal minutes format.\n *\n * @param value - The coordinate value to format.\n * @returns Formatted coordinate string with degrees and decimal minutes (e.g., \"45° 30.1234'\").\n *\n * @example\n * ```typescript\n * toDegreesDecimalMinutes(45.5);\n * // '45° 30.0000''\n * ```\n *\n * @example\n * ```typescript\n * toDegreesDecimalMinutes(-122.4194);\n * // '122° 25.1640''\n * ```\n */\nconst toDegreesDecimalMinutes = (value: number): string => {\n  const { degrees, minutes } = toDdmMagnitude(Math.abs(value), DDM_PRECISION);\n\n  return `${degrees}° ${minutes.toFixed(DDM_PRECISION)}'`;\n};\n\n/**\n * Formats latitude/longitude coordinates in degrees decimal minutes notation.\n *\n * @param coordinates - Tuple of [latitude, longitude] values.\n * @param config - Optional formatting configuration.\n * @returns Formatted coordinate string in degrees decimal minutes format.\n *\n * @example\n * ```typescript\n * formatDegreesDecimalMinutes([37.7749, -122.4194]);\n * // '37° 46.4940' N, 122° 25.1640' W'\n * ```\n *\n * @example\n * ```typescript\n * formatDegreesDecimalMinutes([37.7749, -122.4194], { separator: ' / ' });\n * // '37° 46.4940' N / 122° 25.1640' W'\n * ```\n */\nexport const formatDegreesDecimalMinutes = createFormatter(\n  toDegreesDecimalMinutes,\n);\n"],"mappings":";;;;;;;;;;;;;;;;;;AAgBA,MAAa,gBAAgB;;;;;;;;;;;;;AA0B7B,MAAM,kBACJ,WACA,cAC0C;CAC1C,IAAI,UAAU,KAAK,MAAM,UAAU;CACnC,IAAI,UAAU,SAAS,YAAY,WAAW,IAAI,QAAQ,UAAU,CAAC;AAIrE,YAAW,KAAK,MAAM,UAAU,GAAG;AACnC,YAAW;AAEX,QAAO;EAAE;EAAS;EAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;AA6B7B,MAAa,cACX,OACA,MACA,YAAoB,mBACN;CACd,GAAG,eAAe,KAAK,IAAI,MAAM,EAAE,UAAU;CAC7C,YAAY,cAAc,OAAO,KAAK;CACvC;;;;;;;;;;;;;;;;;;;AAoBD,MAAM,2BAA2B,UAA0B;CACzD,MAAM,EAAE,SAAS,YAAY,eAAe,KAAK,IAAI,MAAM,EAAE,cAAc;AAE3E,QAAO,GAAG,QAAQ,IAAI,QAAQ,QAAQ,cAAc,CAAC;;;;;;;;;;;;;;;;;;;;;AAsBvD,MAAa,8BAA8B,gBACzC,wBACD"}

package/dist/coordinates/latlon/degrees-decimal-minutes/system.js

@@ -11,7 +11,9 @@
  */
 
 
-import { BEARINGS, SYMBOLS, SYMBOL_PATTERNS } from "../internal/index.js";
+import { toPlainDecimalString } from "../internal/plain-decimal.js";
+import { SYMBOL_PATTERNS } from "../internal/index.js";
+import { formatCoordinateSystem } from "../internal/format.js";
 import { parseDegreesDecimalMinutes } from "./parser.js";
 
 //#region src/coordinates/latlon/degrees-decimal-minutes/system.ts
@@ -53,12 +55,11 @@ const systemDegreesDecimalMinutes = {
 		const [degrees, minutes, bear] = arg;
 		return Number.parseFloat(((Number.parseFloat(degrees) + Number.parseFloat(minutes) / 60) * (SYMBOL_PATTERNS.NEGATIVE_BEARINGS.test(bear) ? -1 : 1)).toFixed(9));
 	},
-	toFormat(format, [left, right]) {
-		return [left, right].map((num, index) => {
-			const abs = Math.abs(num);
+	toFormat(format, coordinates) {
+		return formatCoordinateSystem(format, coordinates, (abs) => {
 			const deg = Math.floor(abs);
-			return `${deg} ${Number.parseFloat(((abs - deg) * 60).toFixed(10))} ${BEARINGS[format][index][+(num < 0)]}`;
-		}).join(` ${SYMBOLS.DIVIDER} `);
+			return `${deg} ${toPlainDecimalString(Number.parseFloat(((abs - deg) * 60).toFixed(10)))}`;
+		});
 	}
 };
 

package/dist/coordinates/latlon/degrees-decimal-minutes/system.js.map

@@ -1 +1 @@
-{"version":3,"file":"system.js","names":["systemDegreesDecimalMinutes: CoordinateSystem"],"sources":["../../../../src/coordinates/latlon/degrees-decimal-minutes/system.ts"],"sourcesContent":["// __private-exports\n/*\n * Copyright 2024 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport {\n  BEARINGS,\n  type Compass,\n  type Format,\n  SYMBOL_PATTERNS,\n  SYMBOLS,\n} from '../internal';\nimport { parseDegreesDecimalMinutes } from './parser';\nimport type { CoordinateSystem } from '../internal/coordinate-system';\n\n/**\n * Degrees Decimal Minutes coordinate system implementation.\n *\n * Provides parsing, conversion, and formatting for coordinates in degrees decimal minutes notation.\n * Coordinates are expressed as integer degrees and decimal minutes (e.g., 37° 46.4940' N).\n *\n * @property name - Human-readable name of the coordinate system.\n * @property parse - Parses degrees decimal minutes coordinate strings.\n * @property toFloat - Converts parsed coordinate components to floating point numbers.\n * @property toFormat - Formats numeric coordinates back to degrees decimal minutes string.\n *\n * @example\n * ```typescript\n * // Parse a coordinate string\n * const [coords, errors] = systemDegreesDecimalMinutes.parse('37° 46.4940' N / 122° 25.1640' W', 'LATLON');\n * ```\n *\n * @example\n * ```typescript\n * // Convert to float\n * const lat = systemDegreesDecimalMinutes.toFloat(['37', '46.4940', 'N']);\n * // 37.7749\n * ```\n *\n * @example\n * ```typescript\n * // Format to string\n * const formatted = systemDegreesDecimalMinutes.toFormat('LATLON', [37.7749, -122.4194]);\n * // '37 46.494 N / 122 25.164 W'\n * ```\n */\nexport const systemDegreesDecimalMinutes: CoordinateSystem = {\n  name: 'Degrees Decimal Minutes',\n\n  parse: parseDegreesDecimalMinutes,\n\n  toFloat(arg) {\n    const [degrees, minutes, bear] = arg as [string, string, Compass];\n\n    return Number.parseFloat(\n      (\n        (Number.parseFloat(degrees) + Number.parseFloat(minutes) / 60) *\n        (SYMBOL_PATTERNS.NEGATIVE_BEARINGS.test(bear) ? -1 : 1)\n      ).toFixed(9),\n    );\n  },\n\n  toFormat(format: Format, [left, right]: [number, number]) {\n    return [left, right]\n      .map((num, index) => {\n        const abs = Math.abs(num);\n        const deg = Math.floor(abs);\n        const min = Number.parseFloat(((abs - deg) * 60).toFixed(10));\n\n        return `${deg} ${min} ${BEARINGS[format][index as 0 | 1][+(num < 0)]}`;\n      })\n      .join(` ${SYMBOLS.DIVIDER} `);\n  },\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsDA,MAAaA,8BAAgD;CAC3D,MAAM;CAEN,OAAO;CAEP,QAAQ,KAAK;EACX,MAAM,CAAC,SAAS,SAAS,QAAQ;AAEjC,SAAO,OAAO,aAET,OAAO,WAAW,QAAQ,GAAG,OAAO,WAAW,QAAQ,GAAG,OAC1D,gBAAgB,kBAAkB,KAAK,KAAK,GAAG,KAAK,IACrD,QAAQ,EAAE,CACb;;CAGH,SAAS,QAAgB,CAAC,MAAM,QAA0B;AACxD,SAAO,CAAC,MAAM,MAAM,CACjB,KAAK,KAAK,UAAU;GACnB,MAAM,MAAM,KAAK,IAAI,IAAI;GACzB,MAAM,MAAM,KAAK,MAAM,IAAI;AAG3B,UAAO,GAAG,IAAI,GAFF,OAAO,aAAa,MAAM,OAAO,IAAI,QAAQ,GAAG,CAAC,CAExC,GAAG,SAAS,QAAQ,OAAgB,EAAE,MAAM;IACjE,CACD,KAAK,IAAI,QAAQ,QAAQ,GAAG;;CAElC"}
+{"version":3,"file":"system.js","names":["systemDegreesDecimalMinutes: CoordinateSystem"],"sources":["../../../../src/coordinates/latlon/degrees-decimal-minutes/system.ts"],"sourcesContent":["// __private-exports\n/*\n * Copyright 2024 Hypergiant Galactic Systems Inc. All rights reserved.\n * This file is licensed to you under the Apache License, Version 2.0 (the \"License\");\n * you may not use this file except in compliance with the License. You may obtain a copy\n * of the License at https://www.apache.org/licenses/LICENSE-2.0\n *\n * Unless required by applicable law or agreed to in writing, software distributed under\n * the License is distributed on an \"AS IS\" BASIS, WITHOUT WARRANTIES OR REPRESENTATIONS\n * OF ANY KIND, either express or implied. See the License for the specific language\n * governing permissions and limitations under the License.\n */\n\nimport { type Compass, type Format, SYMBOL_PATTERNS } from '../internal';\nimport { formatCoordinateSystem } from '../internal/format';\nimport { toPlainDecimalString } from '../internal/plain-decimal';\nimport { parseDegreesDecimalMinutes } from './parser';\nimport type { CoordinateSystem } from '../internal/coordinate-system';\n\n/**\n * Degrees Decimal Minutes coordinate system implementation.\n *\n * Provides parsing, conversion, and formatting for coordinates in degrees decimal minutes notation.\n * Coordinates are expressed as integer degrees and decimal minutes (e.g., 37° 46.4940' N).\n *\n * @property name - Human-readable name of the coordinate system.\n * @property parse - Parses degrees decimal minutes coordinate strings.\n * @property toFloat - Converts parsed coordinate components to floating point numbers.\n * @property toFormat - Formats numeric coordinates back to degrees decimal minutes string.\n *\n * @example\n * ```typescript\n * // Parse a coordinate string\n * const [coords, errors] = systemDegreesDecimalMinutes.parse('37° 46.4940' N / 122° 25.1640' W', 'LATLON');\n * ```\n *\n * @example\n * ```typescript\n * // Convert to float\n * const lat = systemDegreesDecimalMinutes.toFloat(['37', '46.4940', 'N']);\n * // 37.7749\n * ```\n *\n * @example\n * ```typescript\n * // Format to string\n * const formatted = systemDegreesDecimalMinutes.toFormat('LATLON', [37.7749, -122.4194]);\n * // '37 46.494 N / 122 25.164 W'\n * ```\n */\nexport const systemDegreesDecimalMinutes: CoordinateSystem = {\n  name: 'Degrees Decimal Minutes',\n\n  parse: parseDegreesDecimalMinutes,\n\n  toFloat(arg) {\n    const [degrees, minutes, bear] = arg as [string, string, Compass];\n\n    return Number.parseFloat(\n      (\n        (Number.parseFloat(degrees) + Number.parseFloat(minutes) / 60) *\n        (SYMBOL_PATTERNS.NEGATIVE_BEARINGS.test(bear) ? -1 : 1)\n      ).toFixed(9),\n    );\n  },\n\n  toFormat(format: Format, coordinates: [number, number]) {\n    return formatCoordinateSystem(format, coordinates, (abs) => {\n      const deg = Math.floor(abs);\n      const min = Number.parseFloat(((abs - deg) * 60).toFixed(10));\n\n      return `${deg} ${toPlainDecimalString(min)}`;\n    });\n  },\n};\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAkDA,MAAaA,8BAAgD;CAC3D,MAAM;CAEN,OAAO;CAEP,QAAQ,KAAK;EACX,MAAM,CAAC,SAAS,SAAS,QAAQ;AAEjC,SAAO,OAAO,aAET,OAAO,WAAW,QAAQ,GAAG,OAAO,WAAW,QAAQ,GAAG,OAC1D,gBAAgB,kBAAkB,KAAK,KAAK,GAAG,KAAK,IACrD,QAAQ,EAAE,CACb;;CAGH,SAAS,QAAgB,aAA+B;AACtD,SAAO,uBAAuB,QAAQ,cAAc,QAAQ;GAC1D,MAAM,MAAM,KAAK,MAAM,IAAI;AAG3B,UAAO,GAAG,IAAI,GAAG,qBAFL,OAAO,aAAa,MAAM,OAAO,IAAI,QAAQ,GAAG,CAAC,CAEnB;IAC1C;;CAEL"}

package/dist/coordinates/latlon/degrees-minutes-seconds/formatter.d.ts

@@ -11,9 +11,52 @@
  */
 
 import { FormatOptions } from "../internal/format.js";
+import { Axis, Hemisphere } from "../internal/ordinal.js";
 
 //#region src/coordinates/latlon/degrees-minutes-seconds/formatter.d.ts
-
+/** Default number of decimal places for degrees-minutes-seconds formatting. */
+declare const DMS_PRECISION = 2;
+/**
+ * Structured degrees-minutes-seconds parts for a single signed coordinate value.
+ *
+ * `degrees`, `minutes`, and `seconds` are non-negative; carry keeps `seconds`
+ * and `minutes` below `60`. The signed value is recoverable from the axis and
+ * `hemisphere`.
+ */
+type DmsParts = {
+  degrees: number;
+  minutes: number;
+  seconds: number;
+  hemisphere: Hemisphere;
+};
+/**
+ * Converts a single signed coordinate value into degrees-minutes-seconds parts.
+ *
+ * Applies the seconds/minutes carry (`60″ → +1′`, `60′ → +1°`) after rounding
+ * so `seconds` and `minutes` never reach `60`, then attaches the hemisphere
+ * letter for the axis.
+ *
+ * This is the display path: it rounds to `precision` and carries. The
+ * lossless round-trip representation returned by `createCoordinate(...).dms()`
+ * lives separately in `degrees-minutes-seconds/system.ts` (`toFormat`, via the
+ * shared `formatCoordinateSystem`), which keeps full precision and applies no
+ * carry so a value survives format → parse unchanged. The two are
+ * intentionally not shared — do not route one through the other.
+ *
+ * @param value - The signed coordinate value.
+ * @param axis - Whether the value is a latitude (`'lat'`) or longitude (`'lon'`).
+ * @param precision - Decimal places for the seconds (default `2`).
+ * @returns The `{ degrees, minutes, seconds, hemisphere }` parts object.
+ *
+ * @remarks pure function
+ *
+ * @example
+ * ```typescript
+ * toDmsParts(-77.0369, 'lon');
+ * // { degrees: 77, minutes: 2, seconds: 12.84, hemisphere: 'W' }
+ * ```
+ */
+declare const toDmsParts: (value: number, axis: Axis, precision?: number) => DmsParts;
 /**
  * Formats latitude/longitude coordinates in degrees minutes seconds notation.
  *
@@ -35,5 +78,5 @@ import { FormatOptions } from "../internal/format.js";
  */
 declare const formatDegreesMinutesSeconds: (coordinates: [number, number], config?: FormatOptions) => string;
 //#endregion
-export { formatDegreesMinutesSeconds };
+export { DMS_PRECISION, DmsParts, formatDegreesMinutesSeconds, toDmsParts };
 //# sourceMappingURL=formatter.d.ts.map