feat: add Pack and FromStrings features

Add two new features for JSON manipulation:
1. Pack: create JSON with format string and values
2. FromStrings: create JSON from string arrays

Implementation includes:
- Add Pack function for format string parsing
- Add FromStrings methods for Object and Array
- Add test cases in yyjson_test.sp
- Add usage examples in README.md

Author: ProjectSky

.github/workflows/ci.yml

@@ -18,12 +18,12 @@ jobs:
     strategy:
       fail-fast: false
       matrix:
-        os: [windows-latest, ubuntu-latest]
+        os: [windows-latest, ubuntu-22.04]
         include:
           - os: windows-latest
             os_short: win
 
-          - os: ubuntu-latest
+          - os: ubuntu-22.04
             os_short: linux
 
     steps:

PackageScript

@@ -40,5 +40,5 @@ for cxx_task in Extension.extensions:
 
 # Copy include files
 CopyFiles('scripting/include', 'addons/sourcemod/scripting/include',
-  [ 'yyjson.inc']
+  [ 'yyjson.inc' ]
 )

README.md

@@ -58,7 +58,7 @@ ambuild
 
 ## Documentation
 * [API Reference](https://github.com/ProjectSky/sm-ext-yyjson/blob/main/scripting/include/yyjson.inc)
-* [Latest Builds](https://github.com/ProjectSky/sm-ext-yyjson/actions)
+* [Latest Release](https://github.com/ProjectSky/sm-ext-yyjson/releases)
 
 ### Basic Examples
 
@@ -231,7 +231,7 @@ delete arr;
 ```cpp
 // Array sorting
 YYJSONArray arr = YYJSON.Parse(
-	"[3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]", .is_mutable_doc = true
+  "[3, 1, 4, 1, 5, 9, 2, 6, 5, 3, 5]", .is_mutable_doc = true
 );
 
 arr.Sort(); // Ascending (default)
@@ -269,6 +269,94 @@ delete mixed;
 delete obj;
 ```
 
+#### Using FromStrings
+```cpp
+// Create object from key-value string arrays
+char pairs[][] = {"name", "test", "type", "demo", "version", "1.0.0"};
+	
+YYJSONObject obj = YYJSONObject.FromStrings(pairs, sizeof(pairs));
+
+/* Output:
+{
+  "name": "test",
+  "type": "demo", 
+  "version": "1.0.0"
+}
+*/
+
+// Create array from string array
+char items[][] = {"apple", "banana", "orange"};
+YYJSONArray arr = YYJSONArray.FromStrings(items, sizeof(items));
+
+/* Output:
+[
+  "apple",
+  "banana", 
+  "orange"
+]
+*/
+
+delete obj;
+delete arr;
+```
+
+#### Using JSON Pack
+```cpp
+// Create object with mixed types
+YYJSON packed = YYJSON.Pack("{s:s,s:i,s:f,s:b,s:n}",
+  "name", "John",
+  "age", 25,
+  "height", 1.75,
+  "active", true,
+  "extra"
+);
+
+/* Output:
+{
+  "name": "John",
+  "age": 25,
+  "height": 1.75,
+  "active": true,
+  "extra": null
+}
+*/
+
+// Create nested structures
+YYJSON nested = YYJSON.Pack("{s:{s:s,s:[i,i,i]}}",
+  "user",
+    "name", "John",
+    "scores", 85, 90, 95
+);
+
+/* Output:
+{
+  "user": {
+    "name": "John",
+    "scores": [85, 90, 95]
+  }
+}
+*/
+
+// Create array with mixed types
+YYJSON array = YYJSON.Pack("[s,i,f,b,n]",
+    "test", 42, 3.14, true
+);
+
+/* Output:
+[
+  "test",
+  42,
+  3.14,
+  true,
+  null
+]
+*/
+
+delete packed;
+delete nested;
+delete array;
+```
+
 ## Working with Immutable Documents
 When parsing JSON documents, you can choose whether to create a mutable or immutable document:
 

pushbuild.txt

@@ -1 +1,2 @@
-some meaningless str
+some meaningless str
+8c68c9448936fdfc437994f46753cdda63318509

scripting/include/yyjson.inc

@@ -66,6 +66,28 @@ enum YYJSON_SORT_ORDER
 
 methodmap YYJSON < Handle
 {
+  /**
+  * Creates a JSON value using a format string and arguments
+  * Format specifiers:
+  * - s: string
+  * - i: integer
+  * - f: float
+  * - b: boolean
+  * - n: null
+  * - {: start object
+  * - }: end object
+  * - [: start array
+  * - ]: end array
+  *
+  * @param format             Format string
+  * @param ...                Arguments based on format string
+  *
+  * @return                   JSON handle
+  *
+  * @error                    If format string is invalid or arguments don't match
+  */
+  public static native any Pack(const char[] format, any ...);
+
   /**
   * Iterates over the object's key-value pairs
   *
@@ -673,6 +695,19 @@ methodmap YYJSONObject < YYJSON
   */
   public native YYJSONObject();
 
+  /**
+  * Creates a new JSON object from an array of strings representing key-value pairs.
+  * The array must contain an even number of strings, where even indices are keys 
+  * and odd indices are values. Keys cannot be empty strings.
+  *
+  * @param pairs             Array of strings containing alternating keys and values.
+  * @param size              Total size of the array (must be even).
+  * @return                  New JSON object handle.
+  * @error                   If array size is invalid, any key is empty, or if creation fails.
+  *
+  */
+  public static native YYJSONObject FromStrings(const char[][] pairs, int size);
+
   /**
   * Loads a JSON object from a file
   *
@@ -927,6 +962,15 @@ methodmap YYJSONArray < YYJSON
   */
   public native YYJSONArray();
 
+  /**
+  * Creates a new JSON array from an array of strings.
+  *
+  * @param strings           Array of strings to create array from.
+  * @param size              Size of the array.
+  * @return                  New JSON array handle, or null if creation failed.
+  */
+  public static native YYJSONArray FromStrings(const char[][] strings, int size);
+
   /**
   * Loads a JSON array from a file
   *

scripting/yyjson_test.sp

@@ -6,7 +6,7 @@ public Plugin myinfo =
 	name = "YYJSON Test Suite",
 	author = "ProjectSky",
 	description = "Test suite for YYJSON extension",
-	version = "1.0.1",
+	version = "1.0.2",
 	url = "https://github.com/ProjectSky/sm-ext-yyjson"
 };
 
@@ -28,6 +28,8 @@ Action Command_RunTests(int args)
 	TestTypeOperations();
 	TestFileOperations();
 	TestImmutabilityOperations();
+	TestPackOperations();
+	TestFromStringsOperations();
 
 	PrintToServer("[YYJSON] All tests completed!");
 	return Plugin_Handled;
@@ -502,6 +504,66 @@ void TestImmutabilityOperations()
 	delete readImmutable;
 }
 
+void TestPackOperations()
+{
+	PrintToServer("[YYJSON] Testing pack operations...");
+	
+	// Test basic pack operation with different types
+	YYJSON packed = YYJSON.Pack("{s:s,s:i,s:f,s:b,s:n}", 
+		"name", "test",
+		"age", 25,
+		"height", 1.75,
+		"active", true,
+		"extra"
+	);
+	
+	PrintToServer("Packed JSON:");
+	PrintJson(packed);
+	
+	// Test nested object packing
+	YYJSON nested = YYJSON.Pack("{s:{s:s,s:[i,i,i]}}", 
+		"user",
+			"name", "test",
+			"scores", 85, 90, 95
+	);
+	
+	PrintToServer("Nested packed JSON:");
+	PrintJson(nested);
+	
+	// Test array packing with mixed types
+	YYJSON array = YYJSON.Pack("[s,i,f,b,n]",
+		"test", 42, 3.14, true
+	);
+	
+	PrintToServer("Array packed JSON:");
+	PrintJson(array);
+	
+	delete packed;
+	delete nested;
+	delete array;
+}
+
+void TestFromStringsOperations()
+{
+	PrintToServer("[YYJSON] Testing FromStrings operations...");
+	
+	// Test object creation from key-value string arrays
+	char pairs[][] = {"name", "test", "type", "demo", "version", "1.0.0"};
+	
+	YYJSONObject obj = YYJSONObject.FromStrings(pairs, sizeof(pairs));
+	PrintToServer("Object from strings:");
+	PrintJson(obj);
+	
+	// Test array creation from string array
+	char items[][] = {"apple", "banana", "orange", "grape"};
+	YYJSONArray arr = YYJSONArray.FromStrings(items, sizeof(items));
+	PrintToServer("Array from strings:");
+	PrintJson(arr);
+	
+	delete obj;
+	delete arr;
+}
+
 // Helper function to print json contents
 void PrintJson(YYJSON data)
 {