react-native-app-data-sharing/build/module/DataSharing.js

This React Native package facilitates seamless and secure data sharing between applications on the same device.

"use strict";

import { NativeModules, Platform } from 'react-native';
import { ErrorCode } from './DataSharingTypes';
import { normalizeOptions } from './NormalizeOptionsUtils.ios';
const LINKING_ERROR = `The package 'react-native-app-data-sharing' doesn't seem to be linked. Make sure: \n\n` + Platform.select({
  ios: "- You have run 'pod install'\n",
  default: ''
}) + '- You rebuilt the app after installing the package\n' + '- You are not using Expo Go\n';
const Data = NativeModules.Data ? NativeModules.Data : new Proxy({}, {
  get() {
    throw new Error(LINKING_ERROR);
  }
});
const IS_ANDROID = Platform.OS === 'android';

/**
 * Handles an error by checking its type and logging an appropriate message.
 * If the error is of type `ErrorType`, it logs the error code and message,
 * then throws a new error with the same information. If the error is not of type
 * `ErrorType`, it throws a generic error indicating an unknown error occurred.
 *
 * @param error - The error to be handled, which can be of any type.
 * @throws Will throw an error with a specific message based on the error code
 * if the error is of type `ErrorType`, or a generic unknown error message otherwise.
 */

const handleError = error => {
  if (isErrorType(error)) {
    switch (error.code) {
      case ErrorCode.VALUE_ERROR:
        console.error(`${ErrorCode.VALUE_ERROR}: ${error.message}`);
        throw new Error(`${ErrorCode.VALUE_ERROR}: ${error.message}`);
      case ErrorCode.KEY_ERROR:
        console.error(`${ErrorCode.KEY_ERROR}: ${error.message}`);
        throw new Error(`${ErrorCode.KEY_ERROR}: ${error.message}`);
      case ErrorCode.SAVE_ERROR:
        console.error(`${ErrorCode.SAVE_ERROR}: ${error.message}`);
        throw new Error(`${ErrorCode.SAVE_ERROR}: ${error.message}`);
      case ErrorCode.UPDATE_ERROR:
        console.error(`${ErrorCode.UPDATE_ERROR}: ${error.message}`);
        throw new Error(`${ErrorCode.UPDATE_ERROR}: ${error.message}`);
      case ErrorCode.DELETE_ERROR:
        console.error(`${ErrorCode.DELETE_ERROR}: ${error.message}`);
        throw new Error(`${ErrorCode.DELETE_ERROR}: ${error.message}`);
      case ErrorCode.CLEAR_ERROR:
        console.error(`${ErrorCode.CLEAR_ERROR}: ${error.message}`);
        throw new Error(`${ErrorCode.CLEAR_ERROR}: ${error.message}`);
      case ErrorCode.NO_DATA_FOUND_ERROR:
        console.error(`${ErrorCode.NO_DATA_FOUND_ERROR}: ${error.message}`);
        throw new Error(`${ErrorCode.NO_DATA_FOUND_ERROR}: ${error.message}`);
      case ErrorCode.ACTION_ERROR:
        console.error(`${ErrorCode.ACTION_ERROR}: ${error.message}`);
        throw new Error(`${ErrorCode.ACTION_ERROR}: ${error.message}`);
      case ErrorCode.UNEXPECTED_ERROR:
        console.error(`${ErrorCode.UNEXPECTED_ERROR}: ${error.message}`);
        throw new Error(`${ErrorCode.UNEXPECTED_ERROR}: ${error.message}`);
    }
  } else {
    throw new Error('An unknown error occurred.');
  }
};

/**
 * Checks if an error is of type `ErrorType`.
 * @param error - The error to be checked
 * @returns `true` if the error is of type `ErrorType`, `false` otherwise
 */
function isErrorType(error) {
  return typeof error === 'object' && error !== null && 'code' in error && 'message' in error;
}

/**
 * Saves a key-value pair to the shared storage.
 *
 * @param key - The key to be saved
 * @param value - The value to be saved
 * @param options - An optional object containing configuration options
 * @returns A promise that resolves to an empty value if the data was saved successfully,
 * or rejects with an error if the data could not be saved.
 */
export const saveData = async (key, value, options) => {
  try {
    const platformOptions = IS_ANDROID ? options?.android : normalizeOptions(options?.ios);
    const result = await Data.saveSharedData(platformOptions, key.toLowerCase(), value);
    return Promise.resolve(result);
  } catch (e) {
    return handleError(e);
  }
};

/**
 * Initializes the shared storage with the provided authorities.
 *
 * @param authorities - An object containing configuration options for the shared storage,
 * with keys for Android and iOS platforms.
 * @returns A promise that resolves to an empty value if the store was initialized successfully,
 * or rejects with an error if the store could not be initialized.
 */
export const initializeStore = authorities => {
  const {
    android,
    ios
  } = authorities || {};
  const storeParams = IS_ANDROID ? [android] : [ios?.accessGroup, ios?.serviceName];
  return Data.initializeStore(...storeParams);
};

/**
 * Retrieves a value from the shared storage.
 *
 * @param key - The key of the data to be retrieved.
 * @param options - An optional object containing configuration options.
 * @returns A promise that resolves to the value stored under the key,
 * or rejects with an error if the value could not be retrieved.
 */
export const getData = async (key, options) => {
  try {
    const platformOptions = IS_ANDROID ? options?.android : normalizeOptions(options?.ios);
    const result = await Data.getSharedData(platformOptions, key.toLowerCase());
    return Promise.resolve(result);
  } catch (e) {
    return handleError(e);
  }
};

/**
 * Retrieves all key-value pairs from the shared storage.
 *
 * @param options - An optional object containing configuration options.
 * @returns A promise that resolves to an object with keys as strings and values as strings,
 * or rejects with an error if the data could not be retrieved, or is undefined if no data is found.
 */
export const getAllSyncData = async options => {
  try {
    const platformOptions = IS_ANDROID ? options?.android : normalizeOptions(options?.ios);
    const result = Data.getAllSharedData(platformOptions);
    return Promise.resolve(result);
  } catch (e) {
    return handleError(e);
  }
};

/**
 * Updates a key-value pair in the shared storage.
 *
 * @param key - The key of the data to be updated.
 * @param value - The new value for the key.
 * @param options - An optional object containing configuration options.
 * @returns A promise that resolves to an empty value if the data was updated successfully,
 * or rejects with an error if the data could not be updated.
 */
export const updateData = async (key, value, options) => {
  try {
    const platformOptions = IS_ANDROID ? options?.android : normalizeOptions(options?.ios);
    const result = await Data.updateSharedData(platformOptions, key.toLowerCase(), value);
    return Promise.resolve(result);
  } catch (e) {
    return handleError(e);
  }
};

/**
 * Deletes a key-value pair from the shared storage.
 *
 * @param key - The key of the data to be deleted.
 * @param options - An optional object containing configuration options.
 * @returns A promise that resolves to an empty value if the data was deleted successfully,
 * or rejects with an error if the data could not be deleted.
 */
export const deleteData = async (key, options) => {
  try {
    const platformOptions = IS_ANDROID ? options?.android : normalizeOptions(options?.ios);
    const result = await Data.deleteSharedData(platformOptions, key.toLowerCase());
    return Promise.resolve(result);
  } catch (e) {
    return handleError(e);
  }
};

/**
 * Clears all data from the shared storage.
 *
 * @param options - An optional object containing configuration options.
 * @returns A promise that resolves to an empty value if the data was cleared successfully,
 * or rejects with an error if the data could not be cleared.
 */
export const clearData = async options => {
  try {
    const platformOptions = IS_ANDROID ? options?.android : normalizeOptions(options?.ios);
    const result = await Data.clearSharedData(platformOptions);
    return Promise.resolve(result);
  } catch (e) {
    return handleError(e);
  }
};
//# sourceMappingURL=DataSharing.js.map