react-native-rook-sdk 2.0.3 → 2.1.0-rc.1

package/ios/RookSources.swift

@@ -0,0 +1,148 @@
+//
+//  RookSources.swift
+//  react-native-rook-sdk
+//
+//  Created by Javier Villanueva on 07/10/25.
+//
+
+import RookSDK
+
+@objc(RookSources)
+public class RookSources: NSObject {
+  
+  lazy var dataSourceManager: DataSourcesManager = {
+    return DataSourcesManager()
+  }()
+  
+  lazy var userManager: UserManager = {
+    return UserManager()
+  }()
+ 
+  /**
+   * Check the authorizers and retrieve the sources available and configured
+   *
+   * @param resolve A block called with a boolean value indicating whether the result.
+   * @param reject A block called if an error occurs.
+   */
+  @objc(getAvailableDataSources:resolve:reject:)
+  public func getAvailableDataSources(
+    _ options: NSDictionary, resolve: @escaping RCTPromiseResolveBlock,  reject: @escaping RCTPromiseRejectBlock
+  ) {
+    Task {
+      do {
+        let redirect = options["redirectURL"] as? String ?? ""
+        
+        let sources = try await self.dataSourceManager.getAvailableDataSources(redirectURL: redirect)
+        let dic = sources.map { source in
+          let enc = EncodableRookDataSource(source)
+          return enc.toDictionary()
+        }
+        
+        DispatchQueue.main.async {
+          resolve(dic)
+        }
+      } catch {
+        DispatchQueue.main.async {
+          reject("AppleHealthGetAvailableDataSources", error.localizedDescription, error as NSError)
+        }
+      }
+    }
+  }
+  
+  /**
+   * Check the authorizers and present a default view.
+   *
+   * @param resolve A block called with a boolean value indicating whether the result.
+   * @param reject A block called if an error occurs.
+   */
+  @objc(presentDataSourceView:resolve:reject:)
+  public func presentDataSourceView(
+    _ options: NSDictionary, resolve: @escaping RCTPromiseResolveBlock,  reject: @escaping RCTPromiseRejectBlock
+  ) {
+    
+    let redirect = options["redirectURL"] as? String ?? ""
+    
+    DispatchQueue.main.sync {
+      self.dataSourceManager.presentDataSourceView(redirectURL: redirect) { result in
+        switch result {
+        case .success(let value):
+            resolve(value)
+        case .failure(let error):
+          reject("AppleHealthPresentDataSources", error.localizedDescription, error as NSError)
+        }
+      }
+    }
+  }
+  
+  /**
+   * Revoke the access to a API source
+   *
+   * @param resolve A block called with a boolean value indicating whether the result is.
+   * @param reject A block called if an error occurs, such as Apple Health not being installed.
+   */
+  @objc(revokeDataSource:resolve:reject:)
+  public func revokeDataSource(
+    _ source: String, resolve: @escaping RCTPromiseResolveBlock,  reject: @escaping RCTPromiseRejectBlock
+  ) {
+    Task {
+      do {
+        let result = try await self.userManager.revokeDataSource(dataSource: source)
+        resolve(result)
+      } catch {
+        reject("AppleHealthRevokeDataSource", error.localizedDescription, error as NSError)
+      }
+    }
+  }
+  
+  @objc(getAuthorizedDataSources:reject:)
+  public func getAuthorizedDataSources(
+    _ resolve: @escaping RCTPromiseResolveBlock,  reject: @escaping RCTPromiseRejectBlock
+  ) {
+    self.dataSourceManager.getAuthorizedDataSources() { result in
+      switch result {
+      case .success(let value):
+        resolve(EncodableStatusDataSources(value).toDictionary())
+      case .failure(let error):
+        reject("AppleHealthGetAuthorizedDataSources", error.localizedDescription, error as NSError)
+      }
+    }
+  }
+  
+  @objc(getDataSourceAuthorizer:resolve:reject:)
+  public func getDataSourceAuthorizer(
+    _ options: NSDictionary, resolve: @escaping RCTPromiseResolveBlock,  reject: @escaping RCTPromiseRejectBlock
+  ) {
+    Task {
+      do {
+        let source = options["dataSource"] as? String ?? ""
+        let redirect = options["redirectURL"] as? String ?? ""
+       
+        let result = try await self.dataSourceManager.getDataSourceAuthorizer(dataSource: source, redirectUrl: redirect)
+        let dic = EncodableDataSourceAuthorizer(result).toDictionary()
+        
+        DispatchQueue.main.async {
+          resolve(dic)
+        }
+      } catch {
+        DispatchQueue.main.async {
+          reject("AppleHealthDataSourceAuthorizer", error.localizedDescription, error as NSError)
+        }
+      }
+    }
+  }
+  
+  @objc(getAuthorizedDataSourcesV2:reject:)
+  public func getAuthorizedDataSourcesV2(
+    _ resolve: @escaping RCTPromiseResolveBlock,  reject: @escaping RCTPromiseRejectBlock
+  ){
+    self.dataSourceManager.getAuthorizedSources { result in
+      switch result {
+      case .success(let value):
+        let dic = value.map{ EncodableDataSource($0).toDictionary() }
+        resolve(dic)
+      case .failure(let error):
+        reject("AppleHealthGetAuthorizedDataSources", error.localizedDescription, error as NSError)
+      }
+    }
+  }
+}

package/ios/RookSourcesModule.mm

@@ -1,117 +1,47 @@
 #import "RookSourcesModule.h"
-#import "RookSDK/RookSDK-Swift.h"
-#import "RCTConvert.h"
+#import <React/RCTBridgeModule.h>
 
-@implementation RookSourcesModule
-
-RCT_EXPORT_MODULE()
-
-DataSourceManagerObjc *sourceManager;
-UserManager* sourceUserManager;
-
-- (void) checkUserInstance {
-  if (sourceUserManager == nil) sourceUserManager = [UserManager new];
-}
-
-- (void) checkSourcesInstance {
-  if (sourceManager == nil) sourceManager = [DataSourceManagerObjc new];
-}
+@interface RCT_EXTERN_MODULE(RookSources, NSObject)
 
+RCT_EXTERN_METHOD(getAvailableDataSources: (NSDictionary *) options
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
 
-/**
- * Check the authorizers and retrieve the sources available and configured 
- *
- * @param resolve A block called with a boolean value indicating whether the result.
- * @param reject A block called if an error occurs.
- */
-RCT_EXPORT_METHOD(getAvailableDataSources: (NSDictionary *) options
+RCT_EXTERN_METHOD(presentDataSourceView: (NSDictionary *) options
                   resolve:(RCTPromiseResolveBlock)resolve
-                  reject:(RCTPromiseRejectBlock)reject) {
-    
-    [self checkSourcesInstance];
+                  reject:(RCTPromiseRejectBlock)reject)
 
-    NSString *redirectURL = [RCTConvert NSString:options[@"redirectURL"]];
-    
-    [sourceManager getAvailableDataSourcesWithRedirectURL:redirectURL
-                                               completion:^(NSArray<NSDictionary<NSString *,id> *> * _Nullable sources, NSError * _Nullable error) {
-        if (error) {
-          reject(error.description, error.localizedDescription, error);
-            return;
-        }
+RCT_EXTERN_METHOD(revokeDataSource: (NSString *) options
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
 
-        if (sources) {
-            resolve(sources);
-            return;
-        }
-    
-        resolve([NSDictionary dictionary]);
-    }];
-}
+RCT_EXTERN_METHOD(getAuthorizedDataSources: (RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
 
-/**
- * Check the authorizers and present a default view. 
- *
- * @param resolve A block called with a boolean value indicating whether the result.
- * @param reject A block called if an error occurs.
- */
-RCT_EXPORT_METHOD(presentDataSourceView: (NSDictionary *) options
+RCT_EXTERN_METHOD(getDataSourceAuthorizer: (NSDictionary *) options
                   resolve:(RCTPromiseResolveBlock)resolve
-                  reject:(RCTPromiseRejectBlock)reject) {
-    [self checkSourcesInstance];
-
-    dispatch_async(dispatch_get_main_queue(), ^{
-        NSString *redirectURL = [RCTConvert NSString:options[@"redirectURL"]];
-        
-        [sourceManager presentDataSourceViewWithRedirectURL:redirectURL completion:^(BOOL succeed, NSError * _Nullable error) {
-            if (error) {
-                reject(error.description, error.localizedDescription, error);
-                return;
-            }
-            
-            resolve(@(succeed));
-        }];
-    });
-}
+                  reject:(RCTPromiseRejectBlock)reject)
 
-/**
- * Revoke the access to a API source 
- *
- * @param resolve A block called with a boolean value indicating whether the result is.
- * @param reject A block called if an error occurs, such as Apple Health not being installed.
- */
-RCT_EXPORT_METHOD(revokeDataSource: (NSString *) source
-                 resolve:(RCTPromiseResolveBlock)resolve
-                 reject:(RCTPromiseRejectBlock)reject) {
+RCT_EXTERN_METHOD(getAuthorizedDataSourcesV2:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+@end
 
-    [self checkUserInstance];
+/*
+@implementation RookSourcesModule
 
-   dispatch_async(dispatch_get_main_queue(), ^{
-       [sourceUserManager revokeDataSourceWithDataSource:source completion:^(BOOL succeed, NSError * _Nullable error) {
-           if (error) {
-               reject(error.description, error.localizedDescription, error);
-               return;
-           }
-           
-           resolve(@(succeed));
-       }];
-     });
-}
+RCT_EXPORT_MODULE()
 
-RCT_EXPORT_METHOD(getAuthorizedDataSources: (RCTPromiseResolveBlock) resolve
-                  reject:(RCTPromiseRejectBlock)reject ) {
-  
-  [self checkSourcesInstance];
+DataSourceManagerObjc *sourceManager;
+UserManager* sourceUserManager;
 
-  [sourceManager getAuthorizedDataSourcesWithCompletion:^(NSArray<NSDictionary<NSString *,id> *> * _Nullable sources, NSError * _Nullable error) {
-    if(error) {
-      reject(error.description, error.localizedDescription, error);
-      return;
-    }
-    
-    resolve(sources);
-  }];
+- (void) checkUserInstance {
+  if (sourceUserManager == nil) sourceUserManager = [UserManager new];
 }
 
+- (void) checkSourcesInstance {
+  if (sourceManager == nil) sourceManager = [DataSourceManagerObjc new];
+}
+ 
 RCT_EXPORT_METHOD(getDataSourceAuthorizer:(NSDictionary *)params
                   resolve:(RCTPromiseResolveBlock) resolve
                   reject:(RCTPromiseRejectBlock)reject ) {
@@ -134,3 +64,4 @@ RCT_EXPORT_METHOD(getDataSourceAuthorizer:(NSDictionary *)params
 }
 
 @end
+*/

package/ios/RookSync.h

@@ -0,0 +1,5 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RookSync: NSObject<RCTBridgeModule>
+
+@end

package/ios/RookSync.m

@@ -0,0 +1,27 @@
+//
+//  RookSync.m
+//  react-native-rook-sdk
+//
+//  Created by Javier Villanueva on 15/09/25.
+//
+
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(RookSync, NSObject)
+
+RCT_EXTERN_METHOD(sync: (RCTResponseSenderBlock) callback)
+
+RCT_EXTERN_METHOD(syncByDate: (NSString *) date
+                  callback: (RCTResponseSenderBlock)callback)
+
+RCT_EXTERN_METHOD(syncByDefinition: (NSString *) summary
+                  syncDate: (NSString *) date
+                  callback: (RCTResponseSenderBlock)callback)
+
+RCT_EXTERN_METHOD(syncEvent:(NSString *) syncDate
+                  event: (NSString *) event
+                  resolve: (RCTPromiseResolveBlock) resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+
+@end

package/ios/RookSync.swift

@@ -0,0 +1,135 @@
+//
+//  RookSyncModule.swift
+//  react-native-rook-sdk
+//
+//  Created by Javier Villanueva on 15/09/25.
+//
+
+import RookSDK
+
+@objc(RookSync)
+public class RookSync: NSObject {
+  lazy var summaryManager: RookSummaryManager = {
+    return RookSummaryManager()
+  }()
+  
+  lazy var eventManager: RookEventsManager = {
+    return RookEventsManager()
+  }()
+  
+  @objc(sync:)
+  public func sync(_ callback: @escaping RCTResponseSenderBlock) {
+    Task {
+      do {
+        let result = try await summaryManager.sync()
+        
+        DispatchQueue.main.async {
+          callback([NSNull(), result])
+        }
+      } catch {
+        DispatchQueue.main.async {
+          callback([error.localizedDescription, false])
+        }
+      }
+    }
+  }
+  
+  @objc(syncByDate:callback:)
+  public func syncByDate(_ date: String, callback: @escaping RCTResponseSenderBlock) {
+    Task {
+      do {
+        
+        guard let parsed = parseStringToDate(date) else {
+          let error: [String: Any] = [
+            "code": "INVALID_DATE",
+            "message": "The date provided is not valid",
+          ]
+          
+          callback([error, false])
+          return
+        }
+        
+        let result = try await summaryManager.sync(parsed)
+        
+        DispatchQueue.main.async {
+          callback([NSNull(), result])
+        }
+        
+      } catch {
+        DispatchQueue.main.async {
+          callback([error.localizedDescription, false])
+        }
+      }
+    }
+  }
+  
+  @objc(syncByDefinition:syncDate:callback:)
+  public func syncByDefinition(_ summary: String, syncDate date: String, callback: @escaping RCTResponseSenderBlock) {
+    Task {
+      do {
+        guard let parsed = parseStringToDate(date) else {
+          let error: [String: Any] = [
+            "code": "INVALID_DATE",
+            "message": "The date provided is not valid",
+          ]
+          
+          callback([error, false])
+          return
+        }
+        
+        guard let type = RookSDK.SummaryTypeToUpload(rawValue: summary) else {
+          let error: [String: Any] = [
+            "code": "INVALID_SUMMARY_TYPE",
+            "message": "The summary type provided is not valid",
+          ]
+          
+          callback([error, false])
+          return
+        }
+        
+        let result = try await summaryManager.sync(parsed, [type])
+        
+        DispatchQueue.main.async {
+          callback([NSNull(), result])
+        }
+        
+      } catch {
+        DispatchQueue.main.async {
+          callback([error.localizedDescription, false])
+        }
+      }
+    }
+  }
+  
+  @objc(syncEvent:event:resolve:reject:)
+  public func syncEvent(
+    _ syncDate: String, event: String, resolve: @escaping RCTPromiseResolveBlock,  reject: @escaping RCTPromiseRejectBlock
+  ) {
+    guard let parsed = parseStringToDate(syncDate) else {
+      reject("AppleHealthSyncEventError", "Invalid date format", nil)
+      return
+    }
+    
+    guard let type = RookSDK.EventTypeToUpload(rawValue: event) else {
+      reject("AppleHealthSyncEventError", "Invalid event type", nil)
+      return
+    }
+    
+    Task {
+      do {
+        let result = try await eventManager.syncEvents(date: parsed, eventType: type)
+        resolve(result)
+      } catch {
+        reject("AppleHealthSyncEventError", error.localizedDescription, nil)
+      }
+    }
+    
+  }
+  
+  func parseStringToDate(_ input: String) -> Date? {
+    let dateFormatter = DateFormatter()
+    dateFormatter.dateFormat = "yyyy-MM-dd"
+    return dateFormatter.date(from: input)
+  }
+  
+}

package/ios/RookSyncModule.h

@@ -2,4 +2,4 @@
 
 @interface RookSyncModule : NSObject<RCTBridgeModule>
 
-@end
+@end

package/ios/RookSyncModule.mm

@@ -1,10 +1,11 @@
 #import "RookSyncModule.h"
 #import "RookSDK/RookSDK-Swift.h"
 
-@implementation RookSyncModule 
+@implementation RookSyncModule
 
 RCT_EXPORT_MODULE()
 
+
 RookSummaryManager *summaryManager;
 RookEventsManager *eventsManager;
 
@@ -381,6 +382,7 @@ RCT_EXPORT_METHOD(syncTodayCaloriesCount: (RCTPromiseResolveBlock) resolve
 
 }
 
+/*
 RCT_EXPORT_METHOD(sync: (RCTResponseSenderBlock)callback) {
   
   [self checkSummariesInstance];
@@ -399,8 +401,9 @@ RCT_EXPORT_METHOD(sync: (RCTResponseSenderBlock)callback) {
       callback(@[[NSNull null], @(result)]);
     }
   }];
-}
+}*/
 
+/*
 RCT_EXPORT_METHOD(syncByDefinition: (NSString *) summary
                   syncDate: (NSString *) syncDate
                   callback: (RCTResponseSenderBlock)callback) {
@@ -426,8 +429,9 @@ RCT_EXPORT_METHOD(syncByDefinition: (NSString *) summary
     }
   }];
   
-}
+}*/
 
+/*
 RCT_EXPORT_METHOD(syncByDate: (NSString *) syncDate
                   callback: (RCTResponseSenderBlock)callback) {
 
@@ -449,8 +453,9 @@ RCT_EXPORT_METHOD(syncByDate: (NSString *) syncDate
     }
   }];
   
-}
+}*/
 
+/*
 RCT_EXPORT_METHOD(syncEvent:(NSString *) syncDate
                   event: (NSString *) event
                   resolve: (RCTPromiseResolveBlock) resolve
@@ -467,5 +472,5 @@ RCT_EXPORT_METHOD(syncEvent:(NSString *) syncDate
     resolve(@(result));
   }];
   
-}
+}*/
 @end

package/ios/SwiftTest.swift

@@ -0,0 +1,18 @@
+import Foundation
+
+// La clase debe heredar de NSObject y tener @objc para ser visible
+@objc(SwiftTest)
+public class SwiftTest: NSObject {
+  
+  // Un método estático (de clase) que también debe ser @objc
+  @objc
+  public static func getGreeting(name: String) -> String {
+    return "Hello, \(name) from Swift! 👋"
+  }
+
+  // Un método de instancia
+  @objc
+  public func showMessage() {
+    print("This is a message from a Swift instance.")
+  }
+}

package/ios/react-native-rook-sdk-Bridging-Header.h

@@ -0,0 +1,12 @@
+//
+//  react-native-rook-sdk-Bridging-Header.h
+//  Pods
+//
+//  Created by Javier Villanueva on 04/09/25.
+//
+
+#ifndef react_native_rook_sdk_Bridging_Header_h
+#define react_native_rook_sdk_Bridging_Header_h
+
+
+#endif /* react_native_rook_sdk_Bridging_Header_h */

package/lib/commonjs/hooks/index.js

@@ -27,6 +27,12 @@ Object.defineProperty(exports, "useRookConfiguration", {
     return _useRookConfiguration.useRookConfiguration;
   }
 });
+Object.defineProperty(exports, "useRookData", {
+  enumerable: true,
+  get: function () {
+    return _useRookData.useRookData;
+  }
+});
 Object.defineProperty(exports, "useRookDataSources", {
   enumerable: true,
   get: function () {
@@ -80,4 +86,5 @@ var _useRookPermissions = require("./useRookPermissions");
 var _useRookSummaries = require("./useRookSummaries");
 var _useRookSync = require("./useRookSync");
 var _useRookVariables = require("./useRookVariables");
+var _useRookData = require("./useRookData");
 //# sourceMappingURL=index.js.map

package/lib/commonjs/hooks/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_useRookAndroidBackgroundSteps","require","_useRookAppleHealth","_useRookAppleHealthVariables","_useRookConfiguration","_useRookDataSources","_useRookEvents","_useRookHealthConnect","_useRookPermissions","_useRookSummaries","_useRookSync","_useRookVariables"],"sourceRoot":"../../../src","sources":["hooks/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,8BAAA,GAAAC,OAAA;AACA,IAAAC,mBAAA,GAAAD,OAAA;AACA,IAAAE,4BAAA,GAAAF,OAAA;AACA,IAAAG,qBAAA,GAAAH,OAAA;AACA,IAAAI,mBAAA,GAAAJ,OAAA;AACA,IAAAK,cAAA,GAAAL,OAAA;AACA,IAAAM,qBAAA,GAAAN,OAAA;AACA,IAAAO,mBAAA,GAAAP,OAAA;AACA,IAAAQ,iBAAA,GAAAR,OAAA;AACA,IAAAS,YAAA,GAAAT,OAAA;AACA,IAAAU,iBAAA,GAAAV,OAAA","ignoreList":[]}
+{"version":3,"names":["_useRookAndroidBackgroundSteps","require","_useRookAppleHealth","_useRookAppleHealthVariables","_useRookConfiguration","_useRookDataSources","_useRookEvents","_useRookHealthConnect","_useRookPermissions","_useRookSummaries","_useRookSync","_useRookVariables","_useRookData"],"sourceRoot":"../../../src","sources":["hooks/index.ts"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,IAAAA,8BAAA,GAAAC,OAAA;AACA,IAAAC,mBAAA,GAAAD,OAAA;AACA,IAAAE,4BAAA,GAAAF,OAAA;AACA,IAAAG,qBAAA,GAAAH,OAAA;AACA,IAAAI,mBAAA,GAAAJ,OAAA;AACA,IAAAK,cAAA,GAAAL,OAAA;AACA,IAAAM,qBAAA,GAAAN,OAAA;AACA,IAAAO,mBAAA,GAAAP,OAAA;AACA,IAAAQ,iBAAA,GAAAR,OAAA;AACA,IAAAS,YAAA,GAAAT,OAAA;AACA,IAAAU,iBAAA,GAAAV,OAAA;AACA,IAAAW,YAAA,GAAAX,OAAA","ignoreList":[]}

package/lib/commonjs/hooks/useRookData.js

@@ -0,0 +1,100 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.useRookData = void 0;
+var _react = require("react");
+var _reactNative = require("react-native");
+var _getNativeModule = _interopRequireDefault(require("../utils/getNativeModule"));
+var _isModuleReady = require("../utils/isModuleReady");
+var _isValidDate = require("../utils/isValidDate");
+var _nativeModules = _interopRequireDefault(require("../utils/nativeModules"));
+var _RookSyncGateContext = require("../context/RookSyncGateContext");
+var _SDKSources = require("../types/SDKSources");
+var _packageInfo = require("../utils/packageInfo");
+function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
+const useRookData = () => {
+  const rookData = (0, _react.useRef)((0, _getNativeModule.default)(_reactNative.Platform.select({
+    android: () => _nativeModules.default.android.LOCAL_DATA,
+    default: () => _nativeModules.default.ios.LOCAL_DATA
+  })()));
+  const {
+    state: {
+      ready
+    }
+  } = (0, _RookSyncGateContext.useRookSyncGateContext)();
+  const getSleepSummary = async ({
+    date,
+    source
+  }) => {
+    (0, _isModuleReady.isModuleReady)(ready);
+    (0, _isValidDate.isValidDate)(date);
+    if (_packageInfo.packageInfo.isAndroid && source === _SDKSources.SDKDataSource.SAMSUNG_HEALTH) {
+      const result = await rookData.current.getSamsungSleepSummary(date);
+      return JSON.parse(result);
+    }
+    if (_packageInfo.packageInfo.isAndroid && source === _SDKSources.SDKDataSource.HEALTH_CONNECT) {
+      const result = await rookData.current.getHealthConnectSleepSummary(date);
+      return JSON.parse(result);
+    }
+    return rookData.current.getAppleHealthSleepSummary(date);
+  };
+  const getPhysicalSummary = async ({
+    date,
+    source
+  }) => {
+    (0, _isModuleReady.isModuleReady)(ready);
+    (0, _isValidDate.isValidDate)(date);
+    if (_packageInfo.packageInfo.isAndroid && source === _SDKSources.SDKDataSource.SAMSUNG_HEALTH) {
+      const result = await rookData.current.getSamsungPhysicalSummary(date);
+      return JSON.parse(result);
+    }
+    if (_packageInfo.packageInfo.isAndroid && source === _SDKSources.SDKDataSource.HEALTH_CONNECT) {
+      const result = await rookData.current.getHealthConnectPhysicalSummary(date);
+      return JSON.parse(result);
+    }
+    return rookData.current.getAppleHealthPhysicalSummary(date);
+  };
+  const getBodySummary = async ({
+    date,
+    source
+  }) => {
+    (0, _isModuleReady.isModuleReady)(ready);
+    (0, _isValidDate.isValidDate)(date);
+    if (_packageInfo.packageInfo.isAndroid && source === _SDKSources.SDKDataSource.SAMSUNG_HEALTH) {
+      const result = await rookData.current.getSamsungBodySummary(date);
+      return JSON.parse(result);
+    }
+    if (_packageInfo.packageInfo.isAndroid && source === _SDKSources.SDKDataSource.HEALTH_CONNECT) {
+      const result = await rookData.current.getHealthConnectBodySummary(date);
+      return JSON.parse(result);
+    }
+    return rookData.current.getAppleHealthBodySummary(date);
+  };
+  const getActivityEvents = async ({
+    date,
+    source
+  }) => {
+    (0, _isModuleReady.isModuleReady)(ready);
+    (0, _isValidDate.isValidDate)(date);
+    if (_packageInfo.packageInfo.isAndroid && source === _SDKSources.SDKDataSource.SAMSUNG_HEALTH) {
+      const result = await rookData.current.getSamsungActivityEvents(date);
+      return JSON.parse(result);
+    }
+    if (_packageInfo.packageInfo.isAndroid && source === _SDKSources.SDKDataSource.HEALTH_CONNECT) {
+      const result = await rookData.current.getHealthConnectActivityEvents(date);
+      return JSON.parse(result);
+    }
+    return rookData.current.getAppleHealthActivityEvents(date);
+  };
+  return {
+    ready,
+    getSleepSummary,
+    getPhysicalSummary,
+    getBodySummary,
+    getActivityEvents
+  };
+};
+exports.useRookData = useRookData;
+//# sourceMappingURL=useRookData.js.map