⚡ general improvements

CHANGELOG.md

@@ -1,3 +1,21 @@
+## 1.5.0-wip
+
+* [FIX] ignore empty query segments before applying `parameterLimit` so delimiters do not consume the limit budget
+* [FIX] skip empty keys during decode to match `qs`
+* [FIX] enforce comma list limits with truncation or throwing, including duplicate key accumulation
+* [FIX] correct UTF-16 surrogate encoding and prevent segment-boundary splits in `Utils.encode`
+* [FIX] decode `ByteArray`/`ByteBuffer` values via charset even when `encode=false`
+* [FIX] ensure `FunctionFilter` results still pass through date serialization and COMMA temporal normalization
+* [FIX] replace undefined holes during list merges and normalize when `parseLists=false`
+* [FIX] detect cycles introduced by filters during encoding
+* [FIX] append scalars to overflow maps during merge to preserve list-limit semantics
+* [FIX] preserve overflow indices/maxIndex when merging `OverflowMap` into `null` targets
+* [FIX] skip `Undefined` values when appending iterables into `OverflowMap` via `combine`
+* [FIX] preserve overflow semantics in merge/combine (overflow sources, negative `listLimit`)
+* [FIX] COMMA list encoding honors ByteArray/ByteBuffer decoding when `encode=false`
+* [CHORE] refactor encode/merge internals to stack-based traversal for deep-nesting safety
+* [CHORE] expand tests for empty segments, comma limits, surrogates, byte buffers, filter date normalization, and overflow edge cases
+
 ## 1.4.4
 
 * [CHORE] update Kotlin to 2.3.10

qs-kotlin/src/main/kotlin/io/github/techouse/qskotlin/internal/Decoder.kt

@@ -21,16 +21,28 @@ internal object Decoder {
     private fun parseListValue(value: Any?, options: DecodeOptions, currentListLength: Int): Any? {
         if (value is String && value.isNotEmpty() && options.comma && value.contains(',')) {
             val splitVal = value.split(',')
-            if (options.throwOnLimitExceeded && splitVal.size > options.listLimit) {
-                throw IndexOutOfBoundsException(
-                    "List limit exceeded. " +
-                        "Only ${options.listLimit} element${if (options.listLimit == 1) "" else "s"} allowed in a list."
-                )
+            if (options.listLimit >= 0) {
+                val remaining = options.listLimit - currentListLength
+                if (
+                    options.throwOnLimitExceeded &&
+                        (currentListLength + splitVal.size) > options.listLimit
+                ) {
+                    throw IndexOutOfBoundsException(
+                        "List limit exceeded. " +
+                            "Only ${options.listLimit} element${if (options.listLimit == 1) "" else "s"} allowed in a list."
+                    )
+                }
+                if (remaining <= 0) return emptyList<String>()
+                return if (splitVal.size <= remaining) splitVal else splitVal.subList(0, remaining)
             }
             return splitVal
         }
 
-        if (options.throwOnLimitExceeded && currentListLength >= options.listLimit) {
+        if (
+            options.listLimit >= 0 &&
+                options.throwOnLimitExceeded &&
+                currentListLength >= options.listLimit
+        ) {
             throw IndexOutOfBoundsException(
                 "List limit exceeded. " +
                     "Only ${options.listLimit} element${if (options.listLimit == 1) "" else "s"} allowed in a list."
@@ -68,13 +80,13 @@ internal object Decoder {
             throw IllegalArgumentException("Parameter limit must be a positive integer.")
         }
 
+        val allParts: List<String> = options.delimiter.split(cleanStr)
         val parts =
             if (limit != null) {
-                val allParts: List<String> = options.delimiter.split(cleanStr)
                 val takeCount: Int = if (options.throwOnLimitExceeded) limit + 1 else limit
-                allParts.take(takeCount)
+                allParts.asSequence().filter { it.isNotEmpty() }.take(takeCount).toList()
             } else {
-                options.delimiter.split(cleanStr)
+                allParts.asSequence().filter { it.isNotEmpty() }.toList()
             }
 
         if (options.throwOnLimitExceeded && limit != null && parts.size > limit) {
@@ -105,6 +117,7 @@ internal object Decoder {
             if (i == skipIndex) continue
 
             val part = parts[i]
+            if (part.isEmpty()) continue
             val bracketEqualsPos = part.indexOf("]=")
             val pos = if (bracketEqualsPos == -1) part.indexOf('=') else bracketEqualsPos + 1
 
@@ -131,6 +144,7 @@ internal object Decoder {
                         options.decodeValue(v as String?, charset)
                     }
             }
+            if (key.isEmpty()) continue
 
             if (
                 value != null &&