✅ add QsNet.Comparison project for qs Node.js compatibility

Author: techouse

QsNet.Comparison/Program.cs

@@ -0,0 +1,113 @@
+using System.Diagnostics.CodeAnalysis;
+using System.Text;
+using STJ = System.Text.Json;
+using NJ = Newtonsoft.Json;
+
+namespace QsNet.Comparison;
+
+[ExcludeFromCodeCoverage]
+internal abstract class Program
+{
+    private static void Main()
+    {
+        Console.OutputEncoding = new UTF8Encoding(false);
+
+        var jsonPath = Path.Combine(AppContext.BaseDirectory, "js", "test_cases.json");
+        if (!File.Exists(jsonPath))
+        {
+            Console.Error.WriteLine($"Missing test_cases.json at {jsonPath}");
+            Environment.Exit(1);
+        }
+
+        var json = File.ReadAllText(jsonPath);
+
+        var cases = STJ.JsonSerializer.Deserialize<List<TestCase>>(json, new STJ.JsonSerializerOptions
+        {
+            PropertyNameCaseInsensitive = true
+        });
+
+        if (cases is null)
+        {
+            Console.Error.WriteLine("No test cases loaded.");
+            Environment.Exit(1);
+        }
+
+        var percentEncodeBrackets = true;
+
+        foreach (var c in cases)
+        {
+            // Convert JSON element -> CLR object graph
+            var dataObj = c.Data.HasValue ? FromJsonElement(c.Data.Value) : null;
+
+            // Encode (optionally percent-encode '[' and ']')
+            var encodedOut = Qs.Encode(dataObj ?? new Dictionary<string, object?>());
+            if (percentEncodeBrackets)
+                encodedOut = encodedOut.Replace("[", "%5B").Replace("]", "%5D");
+            Console.WriteLine($"Encoded: {encodedOut}");
+
+            // Decode and JSON-serialize with Newtonsoft (keeps emojis as real characters)
+            var decodedOut = Qs.Decode(c.Encoded!);
+            Console.WriteLine($"Decoded: {CanonJson(decodedOut)}");
+        }
+    }
+
+    // Use Newtonsoft so emojis aren’t turned into surrogate-pair escapes
+    private static string CanonJson(object? v)
+    {
+        return NJ.JsonConvert.SerializeObject(
+            v,
+            NJ.Formatting.None,
+            new NJ.JsonSerializerSettings
+            {
+                // Default doesn't escape non-ASCII; keep it explicit in case of future changes
+                StringEscapeHandling = NJ.StringEscapeHandling.Default
+            }
+        );
+    }
+
+    private static object? FromJsonElement(STJ.JsonElement e)
+    {
+        switch (e.ValueKind)
+        {
+            case STJ.JsonValueKind.Null:
+            case STJ.JsonValueKind.Undefined:
+                return null;
+
+            case STJ.JsonValueKind.String:
+                return e.GetString();
+
+            case STJ.JsonValueKind.Number:
+                // keep numbers as strings to match qs parse/stringify behavior
+                return e.GetRawText().Trim('"');
+
+            case STJ.JsonValueKind.True:
+            case STJ.JsonValueKind.False:
+                return e.GetBoolean();
+
+            case STJ.JsonValueKind.Array:
+            {
+                var list = new List<object?>();
+                foreach (var item in e.EnumerateArray())
+                    list.Add(FromJsonElement(item));
+                return list;
+            }
+
+            case STJ.JsonValueKind.Object:
+            {
+                var dict = new Dictionary<string, object?>();
+                foreach (var prop in e.EnumerateObject())
+                    dict[prop.Name] = FromJsonElement(prop.Value);
+                return dict;
+            }
+
+            default:
+                return e.GetRawText();
+        }
+    }
+
+    private class TestCase
+    {
+        public string? Encoded { get; set; }
+        public STJ.JsonElement? Data { get; set; }
+    }
+}

QsNet.Comparison/QsNet.Comparison.csproj

@@ -0,0 +1,18 @@
+<Project Sdk="Microsoft.NET.Sdk">
+  <PropertyGroup>
+    <OutputType>Exe</OutputType>
+    <TargetFramework>net8.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsPackable>false</IsPackable>
+    <GeneratePackageOnBuild>false</GeneratePackageOnBuild>
+    <IsPublishable>false</IsPublishable>
+  </PropertyGroup>
+  <ItemGroup>
+    <ProjectReference Include="..\QsNet\QsNet.csproj" />
+    <None Include="js\test_cases.json" CopyToOutputDirectory="PreserveNewest" />
+  </ItemGroup>
+  <ItemGroup>
+    <PackageReference Include="Newtonsoft.Json" Version="13.0.3" />
+  </ItemGroup>
+</Project>

QsNet.Comparison/compare_outputs.sh

@@ -0,0 +1,14 @@
+#!/usr/bin/env bash
+script_dir=$(dirname "$0")
+
+node_output=$(node "$script_dir/js/qs.js")
+cs_output=$(dotnet run --project "$script_dir/../QsNet.Comparison" -c Release)
+
+if [ "$node_output" == "$cs_output" ]; then
+    echo "The outputs are identical."
+    exit 0
+else
+    echo "The outputs are different."
+    diff <(echo "$node_output") <(echo "$cs_output")
+    exit 1
+fi

QsNet.Comparison/js/.gitignore

@@ -0,0 +1,2 @@
+node_modules
+package-lock.json

QsNet.Comparison/js/package.json

@@ -0,0 +1,10 @@
+{
+  "name": "qs_comparison",
+  "version": "1.0.0",
+  "description": "A comparison of query string parsing libraries",
+  "author": "Klemen Tusar",
+  "license": "BSD-3-Clause",
+  "dependencies": {
+    "qs": "^6.14.0"
+  }
+}

QsNet.Comparison/js/qs.js

@@ -0,0 +1,12 @@
+const fs = require('fs');
+const path = require('path');
+const qs = require('qs');
+
+// Use path.join to combine __dirname with the relative path to test_cases.json
+const filePath = path.join(__dirname, 'test_cases.json');
+const e2eTestCases = JSON.parse(fs.readFileSync(filePath).toString());
+
+e2eTestCases.forEach(testCase => {
+    console.log('Encoded:', qs.stringify(testCase.data));
+    console.log('Decoded:', JSON.stringify(qs.parse(testCase.encoded)));
+});