Add limit and offset parameters to whoIsPresent methods

Co-Authored-By: Claude <noreply@anthropic.com>

Author: jguz-pubnub

Package.swift

@@ -18,8 +18,8 @@ let package = Package(
     )
   ],
   dependencies: [
-    .package(url: "https://github.com/pubnub/kmp-chat", exact: "0.15.2-swift"),
-    .package(url: "https://github.com/pubnub/swift", exact: "9.3.2")
+    .package(url: "https://github.com/pubnub/kmp-chat", exact: "0.16.1-swift"),
+    .package(url: "https://github.com/pubnub/swift", exact: "10.1.1")
   ],
   targets: [
     // Targets are the basic building blocks of a package, defining a module or a test suite.

PubNubSwiftChatSDK.xcodeproj/project.pbxproj

@@ -1137,15 +1137,15 @@
 			repositoryURL = "https://github.com/pubnub/kmp-chat";
 			requirement = {
 				kind = exactVersion;
-				version = "0.15.2-swift";
+				version = "0.16.1-swift";
 			};
 		};
 		3DCF7DFA2CD0FFCC00889326 /* XCRemoteSwiftPackageReference "swift" */ = {
 			isa = XCRemoteSwiftPackageReference;
 			repositoryURL = "https://github.com/pubnub/swift";
 			requirement = {
 				kind = exactVersion;
-				version = 9.3.2;
+				version = 10.1.1;
 			};
 		};
 /* End XCRemoteSwiftPackageReference section */

Sources/Chat/Chat+AsyncAwait.swift

@@ -336,11 +336,14 @@ public extension Chat {
 
   /// Returns a list of ``User`` identifiers present on the given ``Channel``.
   ///
-  /// - Parameter channelId: Unique identifier of the channel where you want to check all present users
+  /// - Parameters:
+  ///   - channelId: Unique identifier of the channel where you want to check all present users
+  ///   - limit: The number of occupants to fetch per channel. The maximum value is 1000
+  ///   - offset: The offset to return occupancy results from
   /// - Returns: A value containing collection of user identifiers
-  func whoIsPresent(channelId: String) async throws -> [String] {
+  func whoIsPresent(channelId: String, limit: Int = 1000, offset: Int? = 0) async throws -> [String] {
     try await withCheckedThrowingContinuation { continuation in
-      whoIsPresent(channelId: channelId) {
+      whoIsPresent(channelId: channelId, limit: limit, offset: offset) {
         switch $0 {
         case let .success(userIdentifiers):
           continuation.resume(returning: userIdentifiers)

Sources/Chat/Chat.swift

@@ -256,11 +256,15 @@ public protocol Chat: AnyObject {
   ///
   /// - Parameters:
   ///   - channelId: Unique identifier of the channel where you want to check all present users
+  ///   - limit: The number of occupants to fetch per channel. The maximum value is 1000
+  ///   - offset: The offset to return occupancy results from
   ///   - completion: The async `Result` of the method call
   ///     - **Success**: A value containing collection of user identifiers
   ///     - **Failure**: An `Error` describing the failure
   func whoIsPresent(
     channelId: String,
+    limit: Int,
+    offset: Int?,
     completion: ((Swift.Result<[String], Error>) -> Void)?
   )
 

Sources/Chat/ChatConfiguration.swift

@@ -129,7 +129,7 @@ public enum LogLevel {
   /// The most verbose logging - print all other types of logs and more
   case verbose
 
-  func transform() -> PubNubChat.LogLevel {
+  func transform() -> PubNubChat.LogLevel_ {
     switch self {
     case .off:
       .off

Sources/Chat/ChatImpl.swift

@@ -394,10 +394,14 @@ extension ChatImpl: Chat {
 
   public func whoIsPresent(
     channelId: String,
+    limit: Int = 1000,
+    offset: Int? = 0,
     completion: ((Swift.Result<[String], Error>) -> Void)? = nil
   ) {
     chat.whoIsPresent(
-      channelId: channelId
+      channelId: channelId,
+      limit: Int32(limit),
+      offset: offset?.asKotlinInt
     ).async(caller: self) { (result: FutureResult<ChatImpl, [String]>) in
       switch result.result {
       case let .success(ids):

Sources/Entities/BaseChannel.swift

@@ -131,8 +131,8 @@ final class BaseChannel<C: PubNubChat.Channel_, M: PubNubChat.Message>: Channel
     )
   }
 
-  func whoIsPresent(completion: ((Swift.Result<[String], Error>) -> Void)?) {
-    channel.whoIsPresent().async(caller: self) { (result: FutureResult<BaseChannel, [String]>) in
+  func whoIsPresent(limit: Int, offset: Int?, completion: ((Swift.Result<[String], Error>) -> Void)?) {
+    channel.whoIsPresent(limit: Int32(limit), offset: offset?.asKotlinInt).async(caller: self) { (result: FutureResult<BaseChannel, [String]>) in
       switch result.result {
       case let .success(userIdentifiers):
         completion?(.success(userIdentifiers))

Sources/Entities/Channel+AsyncAwait.swift

@@ -156,10 +156,13 @@ public extension Channel {
 
   /// Returns a list of users present on the ``Channel``.
   ///
+  /// - Parameters:
+  ///   - limit: The number of occupants to fetch per channel. The maximum value is 1000
+  ///   - offset: The offset to return occupancy results from
   /// - Returns: A collection of strings representing `userId`
-  func whoIsPresent() async throws -> [String] {
+  func whoIsPresent(limit: Int = 1000, offset: Int? = 0) async throws -> [String] {
     try await withCheckedThrowingContinuation { continuation in
-      whoIsPresent {
+      whoIsPresent(limit: limit, offset: offset) {
         switch $0 {
         case let .success(collection):
           continuation.resume(returning: collection)

Sources/Entities/Channel.swift

@@ -132,10 +132,14 @@ public protocol Channel: CustomStringConvertible {
   /// Returns a list of users present on the ``Channel``.
   ///
   /// - Parameters:
+  ///   - limit: The number of occupants to fetch per channel. The maximum value is 1000
+  ///   - offset: The offset to return occupancy results from
   ///   - completion: The async `Result` of the method call
   ///     - **Success**: A collection of strings representing `userId`
   ///     - **Failure**: An `Error` describing the failure
   func whoIsPresent(
+    limit: Int,
+    offset: Int?,
     completion: ((Swift.Result<[String], Error>) -> Void)?
   )
 

Sources/Entities/ChannelGroup+AsyncAwait.swift

@@ -122,10 +122,15 @@ public extension ChannelGroup {
 
   /// Returns a collection of users currently present in any channel within the given ``ChannelGroup``.
   ///
+  /// - Parameters:
+  ///   - filter: Expression used to filter the results. Returns only the channels whose properties satisfy the given expression
+  ///   - sort: A collection to specify the sort order
+  ///   - limit: The number of occupants to fetch per channel. The maximum value is 1000
+  ///   - offset: The offset to return occupancy results from
   /// - Returns: A `Dictionary` where the key is a ``Channel`` identifier and the value is an array of present user identifiers
-  func whoIsPresent() async throws -> [String: [String]] {
+  func whoIsPresent(limit: Int = 1000, offset: Int? = 0) async throws -> [String: [String]] {
     try await withCheckedThrowingContinuation { continuation in
-      whoIsPresent {
+      whoIsPresent(limit: limit, offset: offset) {
         switch $0 {
         case let .success(result):
           continuation.resume(returning: result)