Add ExpressibleBy*Literal conformance to LiveMapValue.

The conversion to use literal syntax was done by Cursor; I've vaguely
satisfied myself that it's caught most of the usages but there may be
some it's missed.

Resolves #65.

Author: lawrence-forooghian

Sources/AblyLiveObjects/Public/PublicTypes.swift

@@ -83,6 +83,27 @@ public protocol RealtimeObjects: Sendable {
 
 /// Represents the type of data stored for a given key in a ``LiveMap``.
 /// It may be a primitive value (string, number, boolean, binary data, JSON array, or JSON object), or another ``LiveObject``.
+///
+/// `LiveMapValue` implements Swift's `ExpressibleBy*Literal` protocols. This, in combination with `JSONValue`'s conformance to these protocols, allows you to write type-safe map values using familiar syntax. For example:
+///
+/// ```swift
+/// let map = try await channel.objects.createMap(entries: [
+///     "someStringKey": "someString",
+///     "someIntegerKey": 123,
+///     "someFloatKey": 123.456,
+///     "someTrueKey": true,
+///     "someFalseKey": false,
+///     "someJSONObjectKey": [
+///         "someNestedJSONObjectKey": [
+///             "someOtherKey": "someOtherValue",
+///         ],
+///     ],
+///     "someJSONArrayKey": [
+///         "foo",
+///         42,
+///     ],
+/// ])
+/// ```
 public enum LiveMapValue: Sendable, Equatable {
     case string(String)
     case number(Double)
@@ -185,6 +206,44 @@ public enum LiveMapValue: Sendable, Equatable {
     }
 }
 
+// MARK: - ExpressibleBy*Literal conformances
+
+extension LiveMapValue: ExpressibleByDictionaryLiteral {
+    public init(dictionaryLiteral elements: (String, JSONValue)...) {
+        self = .jsonObject(.init(uniqueKeysWithValues: elements))
+    }
+}
+
+extension LiveMapValue: ExpressibleByArrayLiteral {
+    public init(arrayLiteral elements: JSONValue...) {
+        self = .jsonArray(elements)
+    }
+}
+
+extension LiveMapValue: ExpressibleByStringLiteral {
+    public init(stringLiteral value: String) {
+        self = .string(value)
+    }
+}
+
+extension LiveMapValue: ExpressibleByIntegerLiteral {
+    public init(integerLiteral value: Int) {
+        self = .number(Double(value))
+    }
+}
+
+extension LiveMapValue: ExpressibleByFloatLiteral {
+    public init(floatLiteral value: Double) {
+        self = .number(value)
+    }
+}
+
+extension LiveMapValue: ExpressibleByBooleanLiteral {
+    public init(booleanLiteral value: Bool) {
+        self = .bool(value)
+    }
+}
+
 /// Object returned from an `on` call, allowing the listener provided in that call to be deregistered.
 public protocol OnObjectsEventResponse: Sendable {
     /// Deregisters the listener passed to the `on` call.

Tests/AblyLiveObjectsTests/AblyLiveObjectsTests.swift

@@ -139,13 +139,13 @@ struct AblyLiveObjectsTests {
 
         // Create a map and check its initial entries
         let map = try await channel.objects.createMap(entries: [
-            "boolKey": .bool(true),
-            "numberKey": .number(10),
+            "boolKey": true,
+            "numberKey": 10,
         ])
         #expect(
             try Dictionary(uniqueKeysWithValues: map.entries) == [
-                "boolKey": .bool(true),
-                "numberKey": .number(10),
+                "boolKey": true,
+                "numberKey": 10,
             ],
         )
         let mapSubscription = try map.updates()
@@ -162,8 +162,8 @@ struct AblyLiveObjectsTests {
         #expect(mapUpdate.update == ["counterKey": .updated])
         #expect(
             try Dictionary(uniqueKeysWithValues: map.entries) == [
-                "boolKey": .bool(true),
-                "numberKey": .number(10),
+                "boolKey": true,
+                "numberKey": 10,
                 "counterKey": .liveCounter(counter),
             ],
         )
@@ -180,7 +180,7 @@ struct AblyLiveObjectsTests {
         #expect(mapRemoveUpdate.update == ["boolKey": .removed])
         #expect(
             try Dictionary(uniqueKeysWithValues: map.entries) == [
-                "numberKey": .number(10),
+                "numberKey": 10,
                 "counterKey": .liveCounter(counter),
             ],
         )

Tests/AblyLiveObjectsTests/JS Integration Tests/ObjectsIntegrationTests.swift

@@ -137,12 +137,12 @@ private let primitiveKeyData: [(key: String, data: [String: JSONValue], liveMapV
     (
         key: "stringKey",
         data: ["string": .string("stringValue")],
-        liveMapValue: .string("stringValue")
+        liveMapValue: "stringValue"
     ),
     (
         key: "emptyStringKey",
         data: ["string": .string("")],
-        liveMapValue: .string("")
+        liveMapValue: ""
     ),
     (
         key: "bytesKey",
@@ -167,22 +167,22 @@ private let primitiveKeyData: [(key: String, data: [String: JSONValue], liveMapV
     (
         key: "numberKey",
         data: ["number": .number(1)],
-        liveMapValue: .number(1)
+        liveMapValue: 1
     ),
     (
         key: "zeroKey",
         data: ["number": .number(0)],
-        liveMapValue: .number(0)
+        liveMapValue: 0
     ),
     (
         key: "trueKey",
         data: ["boolean": .bool(true)],
-        liveMapValue: .bool(true)
+        liveMapValue: true
     ),
     (
         key: "falseKey",
         data: ["boolean": .bool(false)],
-        liveMapValue: .bool(false)
+        liveMapValue: false
     ),
 ]
 
@@ -422,7 +422,7 @@ private struct ObjectsIntegrationTests {
                         }
 
                         // MAP_CREATE
-                        let map = try await objects.createMap(entries: ["shouldStay": .string("foo"), "shouldDelete": .string("bar")])
+                        let map = try await objects.createMap(entries: ["shouldStay": "foo", "shouldDelete": "bar"])
                         // COUNTER_CREATE
                         let counter = try await objects.createCounter(count: 1)
 
@@ -449,7 +449,7 @@ private struct ObjectsIntegrationTests {
                         }
 
                         // Perform the operations and await the promise
-                        async let setAnotherKeyPromise: Void = map.set(key: "anotherKey", value: .string("baz"))
+                        async let setAnotherKeyPromise: Void = map.set(key: "anotherKey", value: "baz")
                         async let removeKeyPromise: Void = map.remove(key: "shouldDelete")
                         async let incrementPromise: Void = counter.increment(amount: 10)
                         _ = try await (setAnotherKeyPromise, removeKeyPromise, incrementPromise, operationsAppliedPromise)
@@ -3032,7 +3032,7 @@ private struct ObjectsIntegrationTests {
                         async let mapCreatedPromise: Void = waitForMapKeyUpdate(mapCreatedPromiseUpdates, "map")
 
                         let counter = try await objects.createCounter()
-                        let map = try await objects.createMap(entries: ["foo": .string("bar"), "baz": .liveCounter(counter)])
+                        let map = try await objects.createMap(entries: ["foo": "bar", "baz": .liveCounter(counter)])
                         try await root.set(key: "map", value: .liveMap(map))
                         _ = await mapCreatedPromise
 
@@ -3058,7 +3058,7 @@ private struct ObjectsIntegrationTests {
                         internallyTypedObjects.testsOnly_overridePublish(with: { _ in })
 
                         // prevent publishing of ops to realtime so we guarantee that the initial value doesn't come from a CREATE op
-                        let map = try await objects.createMap(entries: ["foo": .string("bar")])
+                        let map = try await objects.createMap(entries: ["foo": "bar"])
                         #expect(try #require(map.get(key: "foo")?.stringValue) == "bar", "Check map has expected initial value")
                     },
                 ),
@@ -3103,7 +3103,7 @@ private struct ObjectsIntegrationTests {
                             }
                         })
 
-                        let map = try await objects.createMap(entries: ["foo": .string("bar")])
+                        let map = try await objects.createMap(entries: ["foo": "bar"])
 
                         // Map should be created with forged initial value instead of the actual one
                         #expect(try map.get(key: "foo") == nil, "Check key \"foo\" was not set on a map client-side")
@@ -3127,7 +3127,7 @@ private struct ObjectsIntegrationTests {
                         })
 
                         // Create map locally, should have an initial value set
-                        let map = try await objects.createMap(entries: ["foo": .string("bar")])
+                        let map = try await objects.createMap(entries: ["foo": "bar"])
                         let internalMap = try #require(map as? PublicDefaultLiveMap)
                         let mapId = internalMap.proxied.objectID