chore: replace "coordinate" with "value" in XML doc comments and internal identifiers (#235)

The codebase still used "coordinate" terminology throughout XML doc
comments and internal identifiers, despite the API having been
refactored to the generic `TValue` abstraction. This aligns all
documentation and internal naming with the current design.

## XML doc comments (16 files)
- Replaced `geographic coordinate(s)` → `value(s)` in `<summary>`,
`<typeparam>`, `<param>`, and `<returns>` tags across all public and
internal types (`PolylineEncoder`, `PolylineDecoder`,
`IPolylineEncoder`, `IPolylineDecoder`, `IPolylineFormatter`,
`PolylineEncodingOptions`, `PolylineOptions`, `PolylineItemFactory`,
`PolylineFormatter`, `FormatterBuilder`, `PolylineEncoderExtensions`,
`PolylineEncoding`, `Defaults`, `ExceptionGuard`,
`LogWarningExtensions`, `LogDebugExtensions`)
- Updated example pseudocode in `IPolylineEncoder` from `Coordinate` to
`Value` type name

## Internal identifiers
| Before | After |
|---|---|
| `ThrowCoordinateValueOutOfRange` | `ThrowValueOutOfRange` |
| `FormatCoordinateValueMustBeBetween` | `FormatValueMustBeBetween` |
| `Defaults.Coordinate` (nested class) | `Defaults.Value` |
| `coordinateIndex` (log param) | `valueIndex` |
| Log: `"Decoded coordinate: ..."` | `"Decoded value: ..."` |
| Log: `"Current coordinate is at index"` | `"Current value is at
index"` |

All renames are internal — no public API or method parameter names
changed. Tests updated to match new identifiers and log message strings.

---------

Co-authored-by: copilot-swe-agent[bot] <198982749+Copilot@users.noreply.github.com>
Co-authored-by: petesramek <2333452+petesramek@users.noreply.github.com>

Author: Copilot

src/PolylineAlgorithm/Abstraction/IPolylineDecoder.cs

@@ -9,19 +9,19 @@ namespace PolylineAlgorithm.Abstraction;
 using System.Threading;
 
 /// <summary>
-/// Defines a contract for decoding an encoded polyline into a sequence of geographic coordinates.
+/// Defines a contract for decoding an encoded polyline into a sequence of values.
 /// </summary>
 /// <typeparam name="TPolyline">
 /// The type that represents the encoded polyline input. Common implementations use <see cref="string"/>,
 /// but custom wrapper types are allowed to carry additional metadata.
 /// </typeparam>
 /// <typeparam name="TValue">
-/// The coordinate type returned by the decoder. Typical implementations return a struct or class that
+/// The value type returned by the decoder. Typical implementations return a struct or class that
 /// contains latitude and longitude (for example a <c>LatLng</c> type or a <c>ValueTuple&lt;double,double&gt;</c>).
 /// </typeparam>
 public interface IPolylineDecoder<TPolyline, TValue> {
     /// <summary>
-    /// Decodes the specified encoded polyline into an ordered sequence of geographic coordinates.
+    /// Decodes the specified encoded polyline into an ordered sequence of values.
     /// The sequence preserves the original vertex order encoded by the <paramref name="polyline"/>.
     /// </summary>
     /// <param name="polyline">
@@ -35,7 +35,7 @@ public interface IPolylineDecoder<TPolyline, TValue> {
     /// </param>
     /// <returns>
     /// An <see cref="IEnumerable{T}"/> of <typeparamref name="TValue"/> representing the decoded
-    /// latitude/longitude pairs (or equivalent coordinates) in the same order they were encoded.
+    /// latitude/longitude pairs (or equivalent values) in the same order they were encoded.
     /// </returns>
     /// <remarks>
     /// Implementations commonly follow the Google Encoded Polyline Algorithm Format, but this interface

src/PolylineAlgorithm/Abstraction/IPolylineEncoder.cs

@@ -5,12 +5,12 @@
 
 namespace PolylineAlgorithm.Abstraction;
 /// <summary>
-/// Contract for encoding a sequence of geographic coordinates into an encoded polyline representation.
+/// Contract for encoding a sequence of values into an encoded polyline representation.
 /// Implementations interpret the generic <typeparamref name="TValue"/> type and produce an encoded
-/// representation of those coordinates as <typeparamref name="TPolyline"/>.
+/// representation of those values as <typeparamref name="TPolyline"/>.
 /// </summary>
 /// <typeparam name="TValue">
-/// The concrete coordinate representation used by the encoder (for example a struct or class containing
+/// The concrete value representation used by the encoder (for example a struct or class containing
 /// <c>Latitude</c> and <c>Longitude</c> values). Implementations must document the expected shape,
 /// units (typically decimal degrees), and any required fields for <typeparamref name="TValue"/>.
 /// Common shapes:
@@ -27,16 +27,16 @@ namespace PolylineAlgorithm.Abstraction;
 /// - This interface is intentionally minimal to allow different encoding strategies (Google encoded polyline,
 ///   precision/scale variants, or custom compressed formats) to be expressed behind a common contract.
 /// - Implementations should document:
-///   - Coordinate precision and rounding rules (for example 1e-5 for 5-decimal precision).
-///   - Coordinate ordering and whether altitude or additional dimensions are supported.
+///   - Value precision and rounding rules (for example 1e-5 for 5-decimal precision).
+///   - Value ordering and whether altitude or additional dimensions are supported.
 ///   - Thread-safety guarantees: whether instances are safe to reuse concurrently or must be instantiated per-call.
 /// - Implementations are encouraged to be memory-efficient; the API accepts a <see cref="ReadOnlySpan{T}"/>
 ///   to avoid forced allocations when callers already have contiguous memory.
 /// </remarks>
 public interface IPolylineEncoder<TValue, TPolyline> {
     /// <summary>
-    /// Encodes a sequence of geographic coordinates into an encoded polyline representation.
-    /// The order of coordinates in <paramref name="coordinates"/> is preserved in the encoded result.
+    /// Encodes a sequence of values into an encoded polyline representation.
+    /// The order of values in <paramref name="coordinates"/> is preserved in the encoded result.
     /// </summary>
     /// <param name="coordinates">
     /// The collection of <typeparamref name="TValue"/> instances to encode into a polyline.
@@ -49,24 +49,24 @@ public interface IPolylineEncoder<TValue, TPolyline> {
     /// when cancellation is requested. For fast, in-memory encoders cancellation may be best-effort.
     /// </param>
     /// <returns>
-    /// A <typeparamref name="TPolyline"/> containing the encoded polyline that represents the input coordinates.
+    /// A <typeparamref name="TPolyline"/> containing the encoded polyline that represents the input values.
     /// The exact format and any delimiting/terminating characters are implementation-specific and must be
     /// documented by concrete encoder types.
     /// </returns>
     /// <example>
     /// <code>
     /// // Example pseudocode for typical usage with a string-based encoder:
-    /// var coords = new[] {
-    ///     new Coordinate { Latitude = 47.6219, Longitude = -122.3503 },
-    ///     new Coordinate { Latitude = 47.6220, Longitude = -122.3504 }
+    /// var values = new[] {
+    ///     new Value { Latitude = 47.6219, Longitude = -122.3503 },
+    ///     new Value { Latitude = 47.6220, Longitude = -122.3504 }
     /// };
-    /// IPolylineEncoder&lt;Coordinate,string&gt; encoder = new GoogleEncodedPolylineEncoder();
-    /// string encoded = encoder.Encode(coords, CancellationToken.None);
+    /// IPolylineEncoder&lt;Value,string&gt; encoder = new GoogleEncodedPolylineEncoder();
+    /// string encoded = encoder.Encode(values, CancellationToken.None);
     /// </code>
     /// </example>
     /// <remarks>
     /// - Implementations should validate input as appropriate and document any preconditions (for example
-    ///   if coordinates must be within [-90,90] latitude and [-180,180] longitude).
+    ///   if values must be within [-90,90] latitude and [-180,180] longitude).
     /// - For large input sequences, implementations may provide streaming or incremental encoders; those
     ///   variants can still implement this interface by materializing the final encoded result.
     /// </remarks>

src/PolylineAlgorithm/Abstraction/IPolylineFormatter.cs

@@ -13,7 +13,7 @@ namespace PolylineAlgorithm.Abstraction;
 /// produce a <typeparamref name="TPolyline"/> from an encoded character buffer, and extract that buffer
 /// back from a <typeparamref name="TPolyline"/>.
 /// </summary>
-/// <typeparam name="TValue">The coordinate or item type. For example a struct with Latitude/Longitude.</typeparam>
+/// <typeparam name="TValue">The value or item type. For example a struct with Latitude/Longitude.</typeparam>
 /// <typeparam name="TPolyline">The polyline surface type. For example <see cref="string"/> or
 /// <see cref="ReadOnlyMemory{T}"/> of <see cref="char"/>.</typeparam>
 /// <remarks>

src/PolylineAlgorithm/Extensions/PolylineEncoderExtensions.cs

@@ -10,13 +10,13 @@ namespace PolylineAlgorithm.Extensions;
 using System;
 
 /// <summary>
-/// Provides extension methods for the <see cref="IPolylineEncoder{TValue, TPolyline}"/> interface to facilitate encoding geographic coordinates into polylines.
+/// Provides extension methods for the <see cref="IPolylineEncoder{TValue, TPolyline}"/> interface to facilitate encoding values into polylines.
 /// </summary>
 public static class PolylineEncoderExtensions {
     /// <summary>
     /// Encodes an array of <typeparamref name="TValue"/> instances into an encoded polyline.
     /// </summary>
-    /// <typeparam name="TValue">The type that represents a geographic coordinate to encode.</typeparam>
+    /// <typeparam name="TValue">The type that represents a value to encode.</typeparam>
     /// <typeparam name="TPolyline">The type that represents the encoded polyline output.</typeparam>
     /// <param name="encoder">
     /// The <see cref="IPolylineEncoder{TValue, TPolyline}"/> instance used to perform the encoding operation.
@@ -25,7 +25,7 @@ public static class PolylineEncoderExtensions {
     /// The array of <typeparamref name="TValue"/> objects to encode.
     /// </param>
     /// <returns>
-    /// A <typeparamref name="TPolyline"/> instance representing the encoded polyline for the provided coordinates.
+    /// A <typeparamref name="TPolyline"/> instance representing the encoded polyline for the provided values.
     /// </returns>
     /// <exception cref="ArgumentNullException">
     /// Thrown when <paramref name="encoder"/> or <paramref name="values"/> is <see langword="null"/>.

src/PolylineAlgorithm/FormatterBuilder.cs

@@ -12,7 +12,7 @@ namespace PolylineAlgorithm;
 /// <summary>
 /// Provides a fluent builder for constructing a <see cref="PolylineFormatter{TValue, TPolyline}"/>.
 /// </summary>
-/// <typeparam name="TValue">The coordinate or item type from which column values are extracted.</typeparam>
+/// <typeparam name="TValue">The value or item type from which column values are extracted.</typeparam>
 /// <typeparam name="TPolyline">The polyline surface type produced and consumed by the formatter.</typeparam>
 /// <remarks>
 /// <para>

src/PolylineAlgorithm/Internal/Defaults.cs

@@ -11,7 +11,7 @@ namespace PolylineAlgorithm.Internal;
 /// Provides default values and constants used throughout the Polyline Algorithm.
 /// </summary>
 /// <remarks>
-/// Organizes defaults for algorithm parameters, polyline encoding, and geographic coordinates into nested static classes.
+/// Organizes defaults for algorithm parameters, polyline encoding, and geographic values into nested static classes.
 /// </remarks>
 [ExcludeFromCodeCoverage]
 internal static class Defaults {
@@ -51,9 +51,9 @@ internal static class Algorithm {
     }
 
     /// <summary>
-    /// Contains default values and constants for geographic coordinate validation.
+    /// Contains default values and constants for geographic value validation.
     /// </summary>
-    internal static class Coordinate {
+    internal static class Value {
         /// <summary>
         /// Provides constants representing latitude values, including the default, minimum, and maximum valid values.
         /// </summary>

src/PolylineAlgorithm/Internal/Diagnostics/ExceptionGuard.cs

@@ -70,20 +70,20 @@ internal static void ThrowBufferOverflow(string message) {
     }
 
     /// <summary>
-    /// Throws an <see cref="ArgumentOutOfRangeException"/> when a coordinate value is outside the allowed range.
+    /// Throws an <see cref="ArgumentOutOfRangeException"/> when a value is outside the allowed range.
     /// </summary>
-    /// <param name="value">The coordinate value that was out of range.</param>
+    /// <param name="value">The value that was out of range.</param>
     /// <param name="min">Inclusive minimum allowed value.</param>
     /// <param name="max">Inclusive maximum allowed value.</param>
-    /// <param name="paramName">Name of the parameter containing the coordinate.</param>
+    /// <param name="paramName">Name of the parameter containing the value.</param>
 #if NET6_0_OR_GREATER
     [StackTraceHidden]
 #else
     [MethodImpl(MethodImplOptions.NoInlining)]
 #endif
     [DoesNotReturn]
-    internal static void ThrowCoordinateValueOutOfRange(double value, double min, double max, string paramName) {
-        throw new ArgumentOutOfRangeException(paramName, ExceptionMessage.FormatCoordinateValueMustBeBetween(paramName, min, max));
+    internal static void ThrowValueOutOfRange(double value, double min, double max, string paramName) {
+        throw new ArgumentOutOfRangeException(paramName, ExceptionMessage.FormatValueMustBeBetween(paramName, min, max));
     }
 
     /// <summary>
@@ -269,9 +269,9 @@ internal static string FormatMalformedPolyline(long position) =>
             string.Format(CultureInfo.InvariantCulture, PolylineIsMalformedAtFormat, position);
 
         /// <summary>
-        /// Formats a message indicating a coordinate parameter must be within a range.
+        /// Formats a message indicating a value parameter must be within a range.
         /// </summary>
-        internal static string FormatCoordinateValueMustBeBetween(string name, double min, double max) =>
+        internal static string FormatValueMustBeBetween(string name, double min, double max) =>
             string.Format(CultureInfo.InvariantCulture, CoordinateValueMustBeBetweenFormat, name, min, max);
 
         /// <summary>

src/PolylineAlgorithm/Internal/Diagnostics/LogDebugExtensions.cs

@@ -46,12 +46,12 @@ internal static partial class LogDebugExtensions {
     internal static partial void LogOperationFinishedDebug(this ILogger logger, string operationName);
 
     /// <summary>
-    /// Logs a debug message containing the decoded coordinate values and position.
+    /// Logs a debug message containing the decoded values and position.
     /// </summary>
     /// <param name="logger">The <see cref="ILogger"/> used to write the log entry.</param>
     /// <param name="latitude">The decoded latitude value.</param>
     /// <param name="longitude">The decoded longitude value.</param>
-    /// <param name="position">The position in the polyline buffer at which the coordinate was decoded.</param>
-    [LoggerMessage(EVENT_ID_BASE + 4, LOG_LEVEL, "Decoded coordinate: (Latitude: {latitude}, Longitude: {longitude}) at position {position}.")]
+    /// <param name="position">The position in the polyline buffer at which the value was decoded.</param>
+    [LoggerMessage(EVENT_ID_BASE + 4, LOG_LEVEL, "Decoded value: (Latitude: {latitude}, Longitude: {longitude}) at position {position}.")]
     internal static partial void LogDecodedCoordinateDebug(this ILogger logger, double latitude, double longitude, int position);
 }

src/PolylineAlgorithm/Internal/Diagnostics/LogWarningExtensions.cs

@@ -60,9 +60,9 @@ internal static partial class LogWarningExtensions {
     /// </summary>
     /// <param name="logger">The <see cref="ILogger"/> used to write the log entry.</param>
     /// <param name="position">The buffer position where the write was attempted.</param>
-    /// <param name="coordinateIndex">The index of the current coordinate that prevented the write.</param>
-    [LoggerMessage(EVENT_ID_BASE + 4, LOG_LEVEL, "Cannot write to internal buffer at position {position}. Current coordinate is at index {coordinateIndex}.")]
-    internal static partial void LogCannotWriteValueToBufferWarning(this ILogger logger, int position, int coordinateIndex);
+    /// <param name="valueIndex">The index of the current value that prevented the write.</param>
+    [LoggerMessage(EVENT_ID_BASE + 4, LOG_LEVEL, "Cannot write to internal buffer at position {position}. Current value is at index {valueIndex}.")]
+    internal static partial void LogCannotWriteValueToBufferWarning(this ILogger logger, int position, int valueIndex);
 
     /// <summary>
     /// Logs a warning when a polyline is shorter than the minimal required length.

src/PolylineAlgorithm/PolylineDecoder.cs

@@ -15,10 +15,10 @@ namespace PolylineAlgorithm;
 using System.Threading;
 
 /// <summary>
-/// Decodes encoded polyline representations into sequences of geographic coordinates.
+/// Decodes encoded polyline representations into sequences of values.
 /// </summary>
 /// <typeparam name="TPolyline">The type that represents the encoded polyline input.</typeparam>
-/// <typeparam name="TValue">The type that represents a decoded geographic coordinate.</typeparam>
+/// <typeparam name="TValue">The type that represents a decoded value.</typeparam>
 /// <remarks>
 /// Pass a <see cref="PolylineOptions{TValue, TPolyline}"/> that carries a
 /// <see cref="IPolylineFormatter{TValue, TPolyline}"/> to the constructor. The formatter handles
@@ -64,7 +64,7 @@ public PolylineDecoder(PolylineOptions<TValue, TPolyline> options) {
     /// <param name="cancellationToken">A token that can be used to cancel the operation.</param>
     /// <returns>
     /// An <see cref="IEnumerable{T}"/> of <typeparamref name="TValue"/> representing the decoded
-    /// coordinates.
+    /// values.
     /// </returns>
     /// <exception cref="ArgumentNullException">
     /// Thrown when <paramref name="polyline"/> is <see langword="null"/>.