react-native-rook-sdk 4.0.0 → 5.0.0-beta.0

package/{lib/commonjs/context/RookSyncGateContext.js → src/context/RookSyncGateContext.ts}

@@ -1,17 +1,14 @@
-"use strict";
-
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useRookSyncGateContext = exports.RookSyncGateContext = void 0;
-var _react = require("react");
 // RookSyncGateContext.tsx
+import { createContext, useContext, type Dispatch } from 'react';
+import type { RookSyncGateState, Action } from './RookSyncGateTypes';
 
 /* This line of code is creating a context using the `createContext` function provided by React. The
 context being created is named `RookSyncGateContext` and it is defined to hold an object with two
 properties: `state` of type `RookSyncGateState` and `dispatch` of type `Dispatch<Action>`. The
 `Dispatch` type is a generic type that represents a function to dispatch actions. */
-const RookSyncGateContext = exports.RookSyncGateContext = /*#__PURE__*/(0, _react.createContext)(undefined);
+export const RookSyncGateContext = createContext<
+  { state: RookSyncGateState; dispatch: Dispatch<Action> } | undefined
+>(undefined);
 
 /**
  * The function `useRookSyncGateContext` ensures that it is used within the `RookSyncGateProvider`
@@ -20,12 +17,12 @@ const RookSyncGateContext = exports.RookSyncGateContext = /*#__PURE__*/(0, _reac
  * `RookSyncGateContext` using the `useContext` hook. If the context is not found, it throws an error
  * indicating that `useRookSyncGateContext` should be used inside `RookSyncGateProvider`.
  */
-const useRookSyncGateContext = () => {
-  const context = (0, _react.useContext)(RookSyncGateContext);
+export const useRookSyncGateContext = () => {
+  const context = useContext(RookSyncGateContext);
   if (!context) {
-    throw new Error('useRookSyncGateContext should be used inside RookSyncGateProvider');
+    throw new Error(
+      'useRookSyncGateContext should be used inside RookSyncGateProvider'
+    );
   }
   return context;
 };
-exports.useRookSyncGateContext = useRookSyncGateContext;
-//# sourceMappingURL=RookSyncGateContext.js.map

package/src/context/RookSyncGateProvider.tsx

@@ -0,0 +1,82 @@
+/* eslint-disable react-hooks/exhaustive-deps */
+import { useReducer, type FC, useEffect } from 'react';
+import { rookSyncGateReducer } from './RookSyncGateReducer'; // Importa el reducer
+import type {
+  RookSyncGateState,
+  RookSyncGateProviderProps,
+} from './RookSyncGateTypes';
+import { RookSyncGateContext } from './RookSyncGateContext';
+import RookSdk from '../NativeRookSdk';
+import { RookStateManager } from '../modules/components/RookStateManager';
+
+const initialState: RookSyncGateState = {
+  clientUUID: '',
+  environment: 'sandbox',
+  secret: '',
+  bundleId: undefined,
+  packageName: undefined,
+  ready: false,
+  userID: '',
+  permissions: 0,
+  enableLogs: false,
+};
+
+/*
+ * This code snippet is defining a React functional component called `RookSyncGateProvider`.
+ * this define the provider for the SDK
+ */
+const RookSyncGateProvider: FC<RookSyncGateProviderProps> = ({
+  environment,
+  clientUUID,
+  secret,
+  bundleId,
+  packageName,
+  children,
+  enableLogs = false,
+  enableBackgroundSync,
+}) => {
+  const [state, dispatch] = useReducer(rookSyncGateReducer, initialState);
+
+  useEffect(() => {
+    initModule();
+  }, [environment, clientUUID, secret]);
+
+  const initModule = async (): Promise<void> => {
+    dispatch({ type: 'SET_ROOK_ENVIRONMENT', environment });
+    dispatch({ type: 'SET_CLIENT_UUID', clientUUID });
+    dispatch({ type: 'SET_SECRET', secret });
+    dispatch({ type: 'SET_BUNDLE_ID', bundle: bundleId });
+    dispatch({ type: 'SET_PACKAGE_NAME', package: packageName });
+    dispatch({ type: 'SET_ENABLE_LOGS', enableLogs });
+
+    try {
+      await RookSdk.initRook({
+        environment,
+        clientUUID,
+        secret,
+        bundleId,
+        packageName,
+        enableLogs,
+        enableBackground: enableBackgroundSync,
+      });
+
+      dispatch({ type: 'SET_READY', ready: true });
+    } catch (error) {
+      console.log(error);
+    }
+  };
+
+  return (
+    <RookSyncGateContext.Provider value={{ state, dispatch }}>
+      <RookStateManager
+        state={state}
+        enableBackground={enableBackgroundSync}
+        enableLogs={enableLogs}
+      />
+
+      {children}
+    </RookSyncGateContext.Provider>
+  );
+};
+
+export default RookSyncGateProvider;

package/{lib/commonjs/context/RookSyncGateReducer.js → src/context/RookSyncGateReducer.ts}

@@ -1,9 +1,5 @@
-"use strict";
+import type { RookSyncGateState, Action } from './RookSyncGateTypes';
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.rookSyncGateReducer = void 0;
 /**
  * The rookSyncGateReducer function in TypeScript handles various actions to update the state of a
  * RookSyncGate component.
@@ -19,56 +15,33 @@ exports.rookSyncGateReducer = void 0;
  * type provided. The state object is updated with the corresponding values based on the action type.
  * If the action type is not recognized, it returns the current state unchanged.
  */
-const rookSyncGateReducer = (state, action) => {
+export const rookSyncGateReducer = (
+  state: RookSyncGateState,
+  action: Action
+): RookSyncGateState => {
   switch (action.type) {
     case 'SET_READY':
-      return {
-        ...state,
-        ready: action.ready
-      };
+      return { ...state, ready: action.ready };
     case 'SET_ROOK_ENVIRONMENT':
-      return {
-        ...state,
-        environment: action.environment
-      };
+      return { ...state, environment: action.environment };
     case 'SET_CLIENT_UUID':
-      return {
-        ...state,
-        clientUUID: action.clientUUID
-      };
+      return { ...state, clientUUID: action.clientUUID };
     case 'SET_SECRET':
-      return {
-        ...state,
-        secret: action.secret
-      };
+      return { ...state, secret: action.secret };
     case 'SET_BUNDLE_ID':
-      return {
-        ...state,
-        bundleId: action.bundle
-      };
+      return { ...state, bundleId: action.bundle };
     case 'SET_PACKAGE_NAME':
-      return {
-        ...state,
-        packageName: action.package
-      };
+      return { ...state, packageName: action.package };
     case 'SET_USER_ID':
-      return {
-        ...state,
-        userID: action.userID
-      };
+      return { ...state, userID: action.userID };
     case 'SET_ENABLE_LOGS':
-      return {
-        ...state,
-        enableLogs: action.enableLogs
-      };
+      return { ...state, enableLogs: action.enableLogs };
     case 'SET_PERMISSIONS':
       return {
         ...state,
-        permissions: state.permissions + 1
+        permissions: state.permissions + 1,
       };
     default:
       return state;
   }
 };
-exports.rookSyncGateReducer = rookSyncGateReducer;
-//# sourceMappingURL=RookSyncGateReducer.js.map

package/src/context/RookSyncGateTypes.ts

@@ -0,0 +1,40 @@
+import type { ReactNode } from 'react';
+
+export type Environment = 'sandbox' | 'production';
+
+type RookSyncGateState = {
+  clientUUID: string;
+  environment: Environment;
+  secret: string;
+  bundleId?: string;
+  packageName?: string;
+  ready: boolean;
+  userID: string;
+  permissions: number;
+  enableLogs: boolean;
+};
+
+type Action =
+  | { type: 'SET_CLIENT_UUID'; clientUUID: string }
+  | { type: 'SET_ENABLE_LOGS'; enableLogs: boolean }
+  | { type: 'SET_SECRET'; secret: string }
+  | { type: 'SET_BUNDLE_ID'; bundle: string | undefined }
+  | { type: 'SET_PACKAGE_NAME'; package: string | undefined }
+  | { type: 'SET_PERMISSIONS' }
+  | { type: 'SET_READY'; ready: boolean }
+  | { type: 'SET_ROOK_ENVIRONMENT'; environment: Environment }
+  | { type: 'SET_USER_ID'; userID: string };
+
+type RookSyncGateProviderProps = {
+  children: ReactNode;
+  environment: Environment;
+  clientUUID: string;
+  secret: string;
+  bundleId?: string;
+  packageName?: string;
+  enableLogs?: boolean;
+  enableBackgroundSync: boolean;
+  enableEventsBackgroundSync?: boolean;
+};
+
+export type { RookSyncGateState, Action, RookSyncGateProviderProps };

package/{lib/commonjs/hooks/useRookAPISources.js → src/hooks/useRookAPISources.ts}

@@ -1,33 +1,24 @@
-"use strict";
+import RookSdk from '../NativeRookSdk';
+import { isModuleReady } from '../utils/isModuleReady';
+import { Platform } from 'react-native';
+import { useRookSyncGateContext } from '../context/RookSyncGateContext';
+import type { APIDataSource } from '../types/DataSource';
+import type {
+  AuthorizedSource,
+  DataSourceAuthorizer,
+  DataSourceProps,
+} from '../types/AuthorizedSources';
 
-Object.defineProperty(exports, "__esModule", {
-  value: true
-});
-exports.useRookAPISources = void 0;
-var _react = require("react");
-var _isModuleReady = require("../utils/isModuleReady");
-var _reactNative = require("react-native");
-var _RookSyncGateContext = require("../context/RookSyncGateContext");
-var _getNativeModule = _interopRequireDefault(require("../utils/getNativeModule"));
-var _nativeModules = _interopRequireDefault(require("../utils/nativeModules"));
-var _packageInfo = require("../utils/packageInfo");
-function _interopRequireDefault(e) { return e && e.__esModule ? e : { default: e }; }
 /**
  * The `useRookDataSources` hook provides functionality to interact with data sources in Rook,
  * including retrieving available data sources, presenting a connections page, and revoking user
  * authorization for a specific data source.
  * @returns An object is being returned from the `useRookDataSources` hook to allow the user to access to the sources API
  */
-const useRookAPISources = () => {
-  const rookSync = (0, _react.useRef)((0, _getNativeModule.default)(_reactNative.Platform.select({
-    android: () => _nativeModules.default.android.SOURCES,
-    default: () => _nativeModules.default.ios.SOURCES
-  })()));
+export const useRookAPISources = () => {
   const {
-    state: {
-      ready
-    }
-  } = (0, _RookSyncGateContext.useRookSyncGateContext)();
+    state: { ready },
+  } = useRookSyncGateContext();
 
   /**
    * The function `revokeDataSource` revokes user authorization for the specified data source.
@@ -35,9 +26,13 @@ const useRookAPISources = () => {
    * the type of data source that you want to revoke access to. It is of type `DataSourceType`.
    * @returns A Promise<boolean> is being returned from the `revokeDataSource` function.
    */
-  const revokeDataSource = (userid, type) => {
-    (0, _isModuleReady.isModuleReady)(ready);
-    return rookSync.current.revokeDataSource(userid, type);
+  const revokeDataSource = (
+    userid: string,
+    type: APIDataSource
+  ): Promise<boolean> => {
+    isModuleReady(ready);
+
+    return RookSdk.revokeDataSource(userid, type);
   };
 
   /**
@@ -49,9 +44,14 @@ const useRookAPISources = () => {
    * @returns The function `getDataSourceAuthorizer` is returning a `DataSourceAuthorizer` object after
    * parsing the response from `rookSync.current.getDataSourceAuthorizer()` as JSON.
    */
-  const getDataSourceAuthorizer = async props => {
-    const response = await rookSync.current.getDataSourceAuthorizer(props);
-    if (_packageInfo.packageInfo.isAndroid) return JSON.parse(response);
+  const getDataSourceAuthorizer = async (
+    props: DataSourceProps
+  ): Promise<DataSourceAuthorizer> => {
+    const response = await RookSdk.getDataSourceAuthorizer(props);
+
+    if (Platform.OS === 'android')
+      return JSON.parse(response as any) as DataSourceAuthorizer;
+
     return response;
   };
 
@@ -62,18 +62,22 @@ const useRookAPISources = () => {
    * @returns The function `getAuthorizedDataSources` is returning a Promise that will resolve to the
    * result of calling `rookSync.current.getAuthorizedDataSources()`.
    */
-  const getAuthorizedDataSourcesV2 = async userid => {
-    (0, _isModuleReady.isModuleReady)(ready);
-    if (!_packageInfo.packageInfo.isAndroid) return rookSync.current.getAuthorizedDataSourcesV2(userid);
-    const response = await rookSync.current.getAuthorizedDataSourcesV2();
-    return JSON.parse(response);
+  const getAuthorizedDataSourcesV2 = async (
+    userid: string
+  ): Promise<AuthorizedSource[]> => {
+    isModuleReady(ready);
+
+    if (Platform.OS !== 'android')
+      return RookSdk.getAuthorizedDataSourcesV2(userid);
+
+    const response = await RookSdk.getAuthorizedDataSourcesV2(userid);
+    return JSON.parse(response as any) as AuthorizedSource[];
   };
+
   return {
     ready,
     revokeDataSource,
     getDataSourceAuthorizer,
-    getAuthorizedDataSourcesV2
+    getAuthorizedDataSourcesV2,
   };
 };
-exports.useRookAPISources = useRookAPISources;
-//# sourceMappingURL=useRookAPISources.js.map

package/src/hooks/useRookAndroidBackgroundSteps.ts

@@ -0,0 +1,81 @@
+import RookSdk from '../NativeRookSdk';
+import { useRookSyncGateContext } from '../context/RookSyncGateContext';
+import { isModuleReady } from '../utils/isModuleReady';
+import isRunningOnAndroid from '../utils/isRunningOnAndroid';
+
+/**
+ * The `useRookAndroidBackgroundSteps` function provides various methods for managing and retrieving
+ * step count data on Android devices using the Rook module.
+ * @returns The `useRookAndroidBackgroundSteps` function returns a hook with the functions that allows the user to
+ * control de steps sync
+ */
+export const useRookAndroidBackgroundSteps = () => {
+  const {
+    state: { ready },
+  } = useRookSyncGateContext();
+
+  /**
+   * The function `isStepsAvailable` checks if steps data is available.
+   * @returns The function `isStepsAvailable` is returning a promise that resolve in a boolean value.
+   */
+  const isStepsAvailable = async (): Promise<boolean> => {
+    isRunningOnAndroid();
+    isModuleReady(ready);
+
+    return RookSdk.isStepsAvailable();
+  };
+
+  /**
+   * The function `enableBackgroundAndroidSteps` starts collecting of steps during the day
+   * @returns The `enableBackgroundAndroidSteps` function is returning a Promise that resolves to a boolean
+   */
+  const enableBackgroundAndroidSteps = async (): Promise<boolean> => {
+    isRunningOnAndroid();
+    isModuleReady(ready);
+
+    return RookSdk.enableBackgroundAndroidSteps();
+  };
+
+  /**
+   * The function `disableBackgroundAndroidSteps` stops a process of collecting steps during the day
+   * @returns The function `disableBackgroundAndroidSteps` function is returning a Promise that resolves to a boolean
+   */
+  const disableBackgroundAndroidSteps = (): Promise<boolean> => {
+    isRunningOnAndroid();
+    isModuleReady(ready);
+
+    return RookSdk.disableBackgroundAndroidSteps();
+  };
+
+  /**
+   * The function `isBackgroundAndroidStepsActive` checks if steps are active and returns a Promise with a boolean
+   * value.
+   * @returns The function is returning a Promise that resolves to a boolean
+   */
+  const isBackgroundAndroidStepsActive = (): Promise<boolean> => {
+    isRunningOnAndroid();
+    isModuleReady(ready);
+
+    return RookSdk.isBackgroundAndroidStepsActive();
+  };
+
+  /**
+   * The function `getTodayAndroidStepsCount` retrieves the number of steps taken today asynchronously as string.
+   * @returns The function `getTodaySteps` is returning the result of calling
+   */
+  const syncTodayAndroidStepsCount = (): Promise<string> => {
+    isRunningOnAndroid();
+    isModuleReady(ready);
+
+    return RookSdk.syncTodayAndroidStepsCount();
+  };
+
+  return {
+    ready,
+    isStepsAvailable,
+    enableBackgroundAndroidSteps,
+    disableBackgroundAndroidSteps,
+    isBackgroundAndroidStepsActive,
+    syncTodayAndroidStepsCount,
+  };
+};

package/src/hooks/useRookAppleHealth.ts

@@ -0,0 +1,55 @@
+import RookSdk from '../NativeRookSdk';
+
+import { useRookSyncGateContext } from '../context/RookSyncGateContext';
+import { isModuleReady } from '../utils/isModuleReady';
+import { isRunningOniOS } from '../utils/isRunningOniOS';
+
+export const useRookAppleHealth = () => {
+  const {
+    state: { ready },
+  } = useRookSyncGateContext();
+
+  /**
+   * The function `enableBackGroundUpdates` enable background updates and returns a promise
+   * indicating success.
+   * @returns The function `enableBackGroundUpdates` returns a Promise that resolves to a boolean
+   * value.
+   */
+  const enableBackGroundUpdates = (): Promise<boolean> => {
+    isRunningOniOS();
+    isModuleReady(ready);
+
+    return RookSdk.enableBackGroundUpdates();
+  };
+
+  /**
+   * The function `disableBackGroundUpdates` disables background updates and returns a promise
+   * indicating success.
+   * @returns The function `disableBackGroundUpdates` returns a Promise that resolves to a boolean
+   * value.
+   */
+  const disableBackGroundUpdates = (): Promise<boolean> => {
+    isRunningOniOS();
+    isModuleReady(ready);
+
+    return RookSdk.disableBackGroundUpdates();
+  };
+
+  /**
+   * This function checks if background summaries are enabled.
+   * @returns The function `isBackGroundForSummariesEnable` is returning a boolean value
+   */
+  const isBackgroundUpdatesEnabled = async (): Promise<boolean> => {
+    isRunningOniOS();
+    isModuleReady(ready);
+
+    return RookSdk.isBackgroundUpdatesEnabled();
+  };
+
+  return {
+    ready,
+    enableBackGroundUpdates,
+    disableBackGroundUpdates,
+    isBackgroundUpdatesEnabled,
+  };
+};

package/src/hooks/useRookConfiguration.ts

@@ -0,0 +1,106 @@
+import RookSdk, { type DiagnosticState } from '../NativeRookSdk';
+
+import { useRookSyncGateContext } from '../context/RookSyncGateContext';
+import { isModuleReady } from '../utils/isModuleReady';
+import { SDKDataSource } from '../types/SDKSources';
+import { Platform } from 'react-native';
+
+/**
+ * The `useRookConfiguration` hook provides various asynchronous methods for managing the configuration
+ * of the ROOK SDK
+ * @returns The `useRookConfiguration` function returns an object containing that allow the user to configure
+ * the SDK
+ */
+export const useRookConfiguration = () => {
+  const {
+    state: { ready },
+    dispatch,
+  } = useRookSyncGateContext();
+
+  /**
+   * The `getUserID` function retrieves the user ID
+   * @returns The function `getUserID` is returning a Promise that resolves to a string value.
+   */
+  const getUserID = async (): Promise<string> => {
+    isModuleReady(ready);
+
+    const result = await RookSdk.getUserID();
+
+    if (result) dispatch({ type: 'SET_USER_ID', userID: result });
+
+    return result;
+  };
+
+  /**
+   * The function `updateUserID` updates the user ID and returns a boolean indicating the success of
+   * the update.
+   * @param {string} userID - The `userID` parameter is a string that represents the user ID that needs
+   * to be updated in the system.
+   * @returns The `updateUserID` function returns a Promise that resolves to a boolean value.
+   */
+  const updateUserID = async (userID: string): Promise<boolean> => {
+    isModuleReady(ready);
+
+    const result: boolean = await RookSdk.updateUserID(userID);
+
+    dispatch({ type: 'SET_USER_ID', userID });
+
+    return result;
+  };
+
+  /**
+   * This function `syncUserTimeZone` synchronizes the user's time zone using
+   * @returns The `syncUserTimeZone` function returns a boolean value, indicating success or failure
+   */
+  const syncUserTimeZone = async (): Promise<boolean> => {
+    isModuleReady(ready);
+
+    const result: boolean = await RookSdk.syncUserTimeZone();
+    return result;
+  };
+
+  /**
+   * The function `removeUserFromRook` removes a user from a rook services,  If you delete the user from the Rook services you have to create the user again with updateUserID and request permissions.
+   * @returns The `removeUserFromRook` function is returning a boolean value.
+   */
+  const removeUserFromRook = async (
+    sources: SDKDataSource[]
+  ): Promise<boolean> => {
+    isModuleReady(ready);
+
+    dispatch({ type: 'SET_USER_ID', userID: '' });
+
+    return RookSdk.removeUserFromRook(sources);
+  };
+
+  const getDiagnosticState = async (
+    source: SDKDataSource
+  ): Promise<DiagnosticState> => {
+    isModuleReady(ready);
+
+    if (Platform.OS === 'android' && source === SDKDataSource.HEALTH_CONNECT) {
+      const value = await RookSdk.getHealthConnectDiagnosticState();
+      return JSON.parse(value);
+    }
+
+    if (Platform.OS === 'android' && source === SDKDataSource.SAMSUNG_HEALTH) {
+      const value = await RookSdk.getSamsungHealthDiagnosticState();
+      return JSON.parse(value);
+    }
+
+    if (Platform.OS !== 'android' && source === SDKDataSource.APPLE_HEALTH) {
+      return RookSdk.getDiagnosticState();
+    }
+
+    throw new Error('Check the datasource');
+  };
+
+  return {
+    ready,
+    getUserID,
+    updateUserID,
+    removeUserFromRook,
+    syncUserTimeZone,
+    getDiagnosticState,
+  };
+};