index.js

"use strict";

import {Platform, NativeModules} from "react-native";
import packageJson from "./package.json";
const {MixpanelReactNative} = NativeModules;
import MixpanelMain from "mixpanel-react-native/javascript/mixpanel-main";

const DevicePlatform = {
  Unknown: "Unknown",
  Android: "android",
  iOS: "ios",
};

const ERROR_MESSAGE = {
  INVALID_OBJECT: " is not a valid json object",
  INVALID_STRING: " is not a valid string",
  REQUIRED_DOUBLE: " is not a valid number",
};

const PARAMS = {
  TOKEN: "token",
  DISTINCT_ID: "distinctId",
  ALIAS: "alias",
  EVENT_NAME: "eventName",
  GROUP_KEY: "groupKey",
  PROPERTIES: "properties",
  PROPERTY_NAME: "propertyName",
  PROP: "prop",
  NAME: "name",
  CHARGE: "charge",
  PROPERTY_VALUE: "property value",
};

const DEFAULT_OPT_OUT = false;

/**
 * The primary class for integrating Mixpanel with your app.
 */
export class Mixpanel {
  constructor(token, trackAutomaticEvents, useNative = true, storage) {
    if (!StringHelper.isValid(token)) {
      StringHelper.raiseError(PARAMS.TOKEN);
    }
    if (trackAutomaticEvents == null) {
      throw new Error(`trackAutomaticEvents is undefined`);
    }
    this.token = token;
    this.trackAutomaticEvents = trackAutomaticEvents;
    if (!useNative) {
      this.mixpanelImpl = new MixpanelMain(
        token,
        trackAutomaticEvents,
        storage
      );
      return;
    }

    if (!MixpanelReactNative) {
      console.warn(
        "MixpanelReactNative is not available; using JavaScript mode. If you prefer not to use the JavaScript mode, please follow the guide in the GitHub repository: https://github.com/mixpanel/mixpanel-react-native."
      );
      this.mixpanelImpl = new MixpanelMain(
        token,
        trackAutomaticEvents,
        storage
      );
    } else {
      this.mixpanelImpl = MixpanelReactNative;
    }
  }

  /**
   * Initializes Mixpanel
   *
   * @param {boolean} optOutTrackingDefault Optional Whether or not Mixpanel can start tracking by default. See optOutTracking()
   * @param {object} superProperties  Optional A Map containing the key value pairs of the super properties to register
   * @param {string} serverURL Optional Set the base URL used for Mixpanel API requests. See setServerURL()
   *
   */
  async init(
    optOutTrackingDefault = DEFAULT_OPT_OUT,
    superProperties = {},
    serverURL = "https://api.mixpanel.com"
  ) {
    await this.mixpanelImpl.initialize(
      this.token,
      this.trackAutomaticEvents,
      optOutTrackingDefault,
      {...Helper.getMetaData(), ...superProperties},
      serverURL
    );
  }

  /**
   * @deprecated since version 1.3.0. To initialize Mixpanel, please use the instance method `init` instead. See the example below:
   *
   * <pre><code>
   * const trackAutomaticEvents = true;
   * const mixpanel = new Mixpanel('your project token', trackAutomaticEvents);
   * mixpanel.init();
   * </code></pre>
   *
   * Initializes Mixpanel and return an instance of Mixpanel the given project token.
   *
   * @param {string} token your project token.
   * @param {boolean} trackAutomaticEvents Whether or not to automatically track common mobile events
   * @param {boolean} Optional Whether or not Mixpanel can start tracking by default. See optOutTracking()
   *
   */
  static async init(
    token,
    trackAutomaticEvents,
    optOutTrackingDefault = DEFAULT_OPT_OUT
  ) {
    await MixpanelReactNative.initialize(
      token,
      trackAutomaticEvents,
      optOutTrackingDefault,
      Helper.getMetaData(),
      "https://api.mixpanel.com"
    );
    return new Mixpanel(token, trackAutomaticEvents);
  }

  /**
   * Set the base URL used for Mixpanel API requests.
   * Useful if you need to proxy Mixpanel requests. Defaults to https://api.mixpanel.com.
   * To route data to Mixpanel's EU servers, set to https://api-eu.mixpanel.com
   *
   * @param {string} serverURL the base URL used for Mixpanel API requests
   *
   */
  setServerURL(serverURL) {
    this.mixpanelImpl.setServerURL(this.token, serverURL);
  }

  /**
   * This allows enabling or disabling of all Mixpanel logs at run time.
   * All logging is disabled by default. Usually, this is only required if
   * you are running into issues with the SDK that you want to debug
   *
   * @param {boolean} loggingEnabled whether to enable logging
   *
   */
  setLoggingEnabled(loggingEnabled) {
    this.mixpanelImpl.setLoggingEnabled(this.token, loggingEnabled);
  }

  /**
   * This allows enabling or disabling whether or not Mixpanel flushes events
   * when the app enters the background on iOS. This is set to true by default.
   *
   * @param {boolean} flushOnBackground whether to enable logging
   *
   */
  setFlushOnBackground(flushOnBackground) {
    if (Platform.OS === "ios") {
      MixpanelReactNative.setFlushOnBackground(this.token, flushOnBackground);
    } else {
      console.warn(
        "Mixpanel setFlushOnBackground was called and ignored because this method only works on iOS."
      );
    }
  }

  /**
   * This controls whether to automatically send the client IP Address as part of event tracking.
   * With an IP address, geo-location is possible down to neighborhoods within a city,
   * although the Mixpanel Dashboard will just show you city level location specificity.
   *
   * @param {boolean} useIpAddressForGeolocation whether to automatically send the client IP Address.
   * Defaults to true.
   *
   */
  setUseIpAddressForGeolocation(useIpAddressForGeolocation) {
    this.mixpanelImpl.setUseIpAddressForGeolocation(
      this.token,
      useIpAddressForGeolocation
    );
  }

  /**
   * Set the number of events sent in a single network request to the Mixpanel server.
   * By configuring this value, you can optimize network usage and manage the frequency of communication between the client and the server. The maximum size is 50; any value over 50 will default to 50.
   *
   * @param {integer} flushBatchSize whether to automatically send the client IP Address.
   * Defaults to true.
   *
   */
  setFlushBatchSize(flushBatchSize) {
    this.mixpanelImpl.setFlushBatchSize(this.token, flushBatchSize);
  }

  /**
   * Will return true if the user has opted out from tracking.
   *
   * @return {Promise<boolean>} true if user has opted out from tracking. Defaults to false.
   */
  hasOptedOutTracking() {
    return this.mixpanelImpl.hasOptedOutTracking(this.token);
  }

  /**
   * Use this method to opt-in an already opted-out user from tracking. People updates and track
   * calls will be sent to Mixpanel after using this method.
   * This method will internally track an opt-in event to your project.
   *
   */
  optInTracking() {
    this.mixpanelImpl.optInTracking(this.token);
  }

  /**
   * Use this method to opt-out a user from tracking. Events and people updates that haven't been
   * flushed yet will be deleted. Use flush() before calling this method if you want
   * to send all the queues to Mixpanel before.
   *
   * This method will also remove any user-related information from the device.
   */
  optOutTracking() {
    this.mixpanelImpl.optOutTracking(this.token);
  }

  /**
   * Associate all future calls to track() with the user identified by
   * the given distinct id.
   *
   * <p>Calls to track() made before corresponding calls to identify
   * will use an anonymous locally generated distinct id, which means it is best to call identify
   * early to ensure that your Mixpanel funnels and retention analytics can continue to track the
   * user throughout their lifetime. We recommend calling identify when the user authenticates.
   *
   * <p>Once identify is called, the local distinct id persists across restarts of
   * your application.
   *
   * @param {string} distinctId a string uniquely identifying this user. Events sent to
   *     Mixpanel using the same disinct_id will be considered associated with the
   *     same visitor/customer for retention and funnel reporting, so be sure that the given
   *     value is globally unique for each individual user you intend to track.
   * @returns {Promise} A promise that resolves when the identify is successful.
   *     It does not return any value.
   *
   */
  identify(distinctId) {
    return new Promise((resolve, reject) => {
      if (!StringHelper.isValid(distinctId)) {
        StringHelper.raiseError(PARAMS.DISTINCT_ID);
        reject(new Error("Invalid distinctId"));
      }
      this.mixpanelImpl
        .identify(this.token, distinctId)
        .then(() => {
          resolve();
        })
        .catch((err) => {
          reject(err);
        });
    });
  }

  /**
   * @deprecated The alias method creates an alias which Mixpanel will use to remap one id to another.
   * Multiple aliases can point to the same identifier.
   *
   *  `mixpane.alias("New ID", mixpane.distinctId)`
   *  `mixpane.alias("Newer ID", mixpane.distinctId)`
   *
   * <p>This call does not identify the user after. You must still call identify()
   *  if you wish the new alias to be used for Events and People.
   *
   * @param {string} alias A unique identifier that you want to use as an identifier for this user.
   * @param {string} distinctId the current distinct_id that alias will be mapped to.
   */
  alias(alias, distinctId) {
    if (!StringHelper.isValid(alias)) {
      StringHelper.raiseError(PARAMS.ALIAS);
    }
    if (!StringHelper.isValid(distinctId)) {
      StringHelper.raiseError(PARAMS.DISTINCT_ID);
    }
    this.mixpanelImpl.alias(this.token, alias, distinctId);
  }

  /**
   * Track an event.
   *
   * <p>Every call to track eventually results in a data point sent to Mixpanel. These data points
   * are what are measured, counted, and broken down to create your Mixpanel reports. Events
   * have a string name, and an optional set of name/value pairs that describe the properties of
   * that event.
   *
   * @param {string} eventName The name of the event to send
   * @param {object} properties A Map containing the key value pairs of the properties to include in this event.
   *                   Pass null if no extra properties exist.
   */
  track(eventName, properties) {
    if (!StringHelper.isValid(eventName)) {
      StringHelper.raiseError(PARAMS.EVENT_NAME);
    }
    if (!ObjectHelper.isValidOrUndefined(properties)) {
      ObjectHelper.raiseError(PARAMS.PROPERTIES);
    }
    this.mixpanelImpl.track(this.token, eventName, {
      ...Helper.getMetaData(),
      ...properties,
    });
  }

  /**
   * Returns a Mixpanel People object that can be used to set and increment
   * People Analytics properties.
   *
   * @return {People} an instance of People that you can use to update
   *     records in Mixpanel People Analytics
   */
  getPeople() {
    if (this.people) {
      return this.people;
    } else {
      this.people = new People(this.token, this.mixpanelImpl);
      return this.people;
    }
  }

  /**
   * Track an event with specific groups.
   *
   * <p>Every call to track eventually results in a data point sent to Mixpanel. These data points
   * are what are measured, counted, and broken down to create your Mixpanel reports. Events
   * have a string name, and an optional set of name/value pairs that describe the properties of
   * that event. Group key/value pairs are upserted into the property map before tracking.
   *
   * @param {string} eventName The name of the event to send
   * @param {object} properties A Map containing the key value pairs of the properties to include in this event.
   *                   Pass null if no extra properties exist.
   * @param {object} groups A Map containing the group key value pairs for this event.
   *
   */
  trackWithGroups(eventName, properties, groups) {
    if (!StringHelper.isValid(eventName)) {
      StringHelper.raiseError(PARAMS.EVENT_NAME);
    }
    if (!ObjectHelper.isValidOrUndefined(properties)) {
      ObjectHelper.raiseError(PARAMS.PROPERTIES);
    }
    this.mixpanelImpl.trackWithGroups(
      this.token,
      eventName,
      {
        ...Helper.getMetaData(),
        ...properties,
      },
      groups
    );
  }

  /**
   * Set the group this user belongs to.
   *
   * @param {string} groupKey The property name associated with this group type (must already have been set up).
   * @param {object} groupID The group the user belongs to.
   */
  setGroup(groupKey, groupID) {
    if (!StringHelper.isValid(groupKey)) {
      StringHelper.raiseError(PARAMS.GROUP_KEY);
    }
    this.mixpanelImpl.setGroup(this.token, groupKey, groupID);
  }

  /**
   * Returns a MixpanelGroup object that can be used to set and increment
   * Group Analytics properties.
   *
   * @param {string} groupKey String identifying the type of group (must be already in use as a group key)
   * @param {object} groupID Object identifying the specific group
   * @return an instance of MixpanelGroup that you can use to update
   *     records in Mixpanel Group Analytics
   */
  getGroup(groupKey, groupID) {
    if (this.group) {
      return this.group;
    } else {
      this.group = new MixpanelGroup(
        this.token,
        groupKey,
        groupID,
        this.mixpanelImpl
      );
      return this.group;
    }
  }

  /**
   * Add a group to this user's membership for a particular group key
   *
   * @param {string} groupKey The property name associated with this group type (must already have been set up).
   * @param {object} groupID The new group the user belongs to.
   */
  addGroup(groupKey, groupID) {
    if (!StringHelper.isValid(groupKey)) {
      StringHelper.raiseError(PARAMS.GROUP_KEY);
    }
    this.mixpanelImpl.addGroup(this.token, groupKey, groupID);
  }

  /**
   * Remove a group from this user's membership for a particular group key
   *
   * @param {string} groupKey The property name associated with this group type (must already have been set up).
   * @param {object} groupID The group value to remove.
   */
  removeGroup(groupKey, groupID) {
    if (!StringHelper.isValid(groupKey)) {
      StringHelper.raiseError(PARAMS.GROUP_KEY);
    }
    this.mixpanelImpl.removeGroup(this.token, groupKey, groupID);
  }

  /**
   * Permanently deletes this group's record from Group Analytics.
   *
   * @param {string} groupKey String identifying the type of group (must be already in use as a group key)
   * @param {object} groupID Object identifying the specific group
   * <p>Calling deleteGroup deletes an entire record completely. Any future calls
   * to Group Analytics using the same group value will create and store new values.
   */
  deleteGroup(groupKey, groupID) {
    if (!StringHelper.isValid(groupKey)) {
      StringHelper.raiseError(PARAMS.GROUP_KEY);
    }
    this.mixpanelImpl.deleteGroup(this.token, groupKey, groupID);
  }

  /**
   * Register properties that will be sent with every subsequent call to track().
   *
   * <p>SuperProperties are a collection of properties that will be sent with every event to Mixpanel,
   * and persist beyond the lifetime of your application.
   *
   * <p>Setting a superProperty with registerSuperProperties will store a new superProperty,
   * possibly overwriting any existing superProperty with the same name (to set a
   * superProperty only if it is currently unset, use registerSuperPropertiesOnce())
   *
   * <p>SuperProperties will persist even if your application is taken completely out of memory.
   * to remove a superProperty, call unregisterSuperProperty() or clearSuperProperties()
   *
   * @param {object} properties A Map containing super properties to register
   */
  registerSuperProperties(properties) {
    if (!ObjectHelper.isValidOrUndefined(properties)) {
      ObjectHelper.raiseError(PARAMS.PROPERTIES);
    }
    this.mixpanelImpl.registerSuperProperties(this.token, properties || {});
  }

  /**
   * Register super properties for events, only if no other super property with the
   * same names has already been registered.
   *
   * <p>Calling registerSuperPropertiesOnce will never overwrite existing properties.
   *
   * @param {object} properties A Map containing the super properties to register.
   */
  registerSuperPropertiesOnce(properties) {
    if (!ObjectHelper.isValidOrUndefined(properties)) {
      ObjectHelper.raiseError(PARAMS.PROPERTIES);
    }
    this.mixpanelImpl.registerSuperPropertiesOnce(this.token, properties || {});
  }

  /**
   * Remove a single superProperty, so that it will not be sent with future calls to track().
   *
   * <p>If there is a superProperty registered with the given name, it will be permanently
   * removed from the existing superProperties.
   * To clear all superProperties, use clearSuperProperties()
   *
   * @param {string} propertyName name of the property to unregister
   */
  unregisterSuperProperty(propertyName) {
    if (!StringHelper.isValid(propertyName)) {
      StringHelper.raiseError(PARAMS.PROPERTY_NAME);
    }
    this.mixpanelImpl.unregisterSuperProperty(this.token, propertyName);
  }

  /**
   * Returns a json object of the user's current super properties
   *
   *<p>SuperProperties are a collection of properties that will be sent with every event to Mixpanel,
   * and persist beyond the lifetime of your application.
   *
   * @return {Promise<object>} Super properties for this Mixpanel instance.
   */
  getSuperProperties() {
    return this.mixpanelImpl.getSuperProperties(this.token);
  }

  /**
   * Erase all currently registered superProperties.
   *
   * <p>Future tracking calls to Mixpanel will not contain the specific
   * superProperties registered before the clearSuperProperties method was called.
   *
   * <p>To remove a single superProperty, use unregisterSuperProperty()
   */
  clearSuperProperties() {
    this.mixpanelImpl.clearSuperProperties(this.token);
  }

  /**
   * Begin timing of an event. Calling timeEvent("Thing") will not send an event, but
   * when you eventually call track("Thing"), your tracked event will be sent with a "$duration"
   * property, representing the number of seconds between your calls.
   *
   * @param {string} eventName the name of the event to track with timing.
   */
  timeEvent(eventName) {
    if (!StringHelper.isValid(eventName)) {
      StringHelper.raiseError(PARAMS.EVENT_NAME);
    }
    this.mixpanelImpl.timeEvent(this.token, eventName);
  }

  /**
   * Retrieves the time elapsed for the named event since timeEvent() was called.
   *
   * @param {string} eventName the name of the event to be tracked that was previously called with timeEvent()
   *
   * @return {Promise<number>} Time elapsed since timeEvent(String) was called for the given eventName.
   */
  eventElapsedTime(eventName) {
    if (!StringHelper.isValid(eventName)) {
      StringHelper.raiseError(PARAMS.EVENT_NAME);
    }
    return this.mixpanelImpl.eventElapsedTime(this.token, eventName);
  }

  /**
      Clear super properties and generates a new random distinctId for this instance.
      Useful for clearing data when a user logs out.
     */
  reset() {
    this.mixpanelImpl.reset(this.token);
  }

  /**
   * Returns the current distinct id of the user.
   * This is either the id automatically generated by the library or the id that has been passed by a call to identify().
   *
   * example of usage:
   * <pre>
   * <code>
   * const distinctId = await mixpanel.getDistinctId();
   * </code>
   * </pre>
   *
   * @return {Promise<string>} A Promise to the distinct id associated with Mixpanel event and People Analytics
   *
   */
  getDistinctId() {
    return this.mixpanelImpl.getDistinctId(this.token);
  }

  /**
   * Returns the current device id of the device.
   * This id automatically generated by the library and regenerated when logout or reset is called.
   *
   * example of usage:
   * <pre>
   * <code>
   * const deviceId = await mixpanel.getDeviceId();
   * </code>
   * </pre>
   *
   * @return {Promise<string>} A Promise to the device id
   *
   */
  getDeviceId() {
    return this.mixpanelImpl.getDeviceId(this.token);
  }

  /**
   * Push all queued Mixpanel events and People Analytics changes to Mixpanel servers.
   *
   * <p>Events and People messages are pushed gradually throughout
   * the lifetime of your application. This means that to ensure that all messages
   * are sent to Mixpanel when your application is shut down, you will
   * need to call flush() to let the Mixpanel library know it should
   * send all remaining messages to the server.
   */
  flush() {
    this.mixpanelImpl.flush(this.token);
  }
}

/**
 * Core class for using Mixpanel People Analytics features.
 *
 * <p>The People object is used to update properties in a user's People Analytics record,
 * and to manage the receipt of push notifications sent via Mixpanel Engage.
 * For this reason, it's important to call identify(String) on the People
 * object before you work with it. Once you call identify, the user identity will
 * persist across stops and starts of your application, until you make another
 * call to identify using a different id.
 *
 */
export class People {
  constructor(token, mixpanelImpl) {
    if (!StringHelper.isValid(token)) {
      StringHelper.raiseError(PARAMS.TOKEN);
    }
    this.token = token;
    this.mixpanelImpl = mixpanelImpl;
  }

  /**
   * Sets a single property with the given name and value for this user.
   * The given name and value will be assigned to the user in Mixpanel People Analytics,
   * possibly overwriting an existing property with the same name.
   *
   * @param {string} prop The name of the Mixpanel property. This must be a String, for example "Zip Code"
   * @param {object} to The value of the Mixpanel property. For "Zip Code", this value might be the String "90210"
   */
  set(prop, to) {
    let properties = {};
    if (ObjectHelper.isValid(prop)) {
      properties = JSON.parse(JSON.stringify(prop || {}));
    } else {
      if (!StringHelper.isValid(prop)) {
        StringHelper.raiseError(PARAMS.PROP);
      }
      properties[prop] = to;
    }
    this.mixpanelImpl.set(this.token, properties);
  }

  /**
   * Works just like set(), except it will not overwrite existing property values. This is useful for properties like "First login date".
   *
   * @param {string} prop The name of the Mixpanel property. This must be a String, for example "Zip Code"
   * @param {object} to The value of the Mixpanel property. For "Zip Code", this value might be the String "90210"
   */
  setOnce(prop, to) {
    let properties = {};
    if (ObjectHelper.isValid(prop)) {
      prop = prop || {};
      properties = JSON.parse(JSON.stringify(prop));
    } else {
      if (!StringHelper.isValid(prop)) {
        StringHelper.raiseError(PARAMS.PROP);
      }
      properties[prop] = to;
    }
    this.mixpanelImpl.setOnce(this.token, properties);
  }

  /**
   * Add the given amount to an existing property on the identified user. If the user does not already
   * have the associated property, the amount will be added to zero. To reduce a property,
   * provide a negative number for the value.
   *
   * @param {string} prop the People Analytics property that should have its value changed
   * @param {number} by the amount to be added to the current value of the named property
   *
   */
  increment(prop, by) {
    var add = {};
    if (ObjectHelper.isValid(prop)) {
      Object.keys(prop).forEach(function (key) {
        var val = prop[key];
        if (isNaN(parseFloat(val))) {
          throw new Error(
            `${PARAMS.PROPERTY_VALUE}${ERROR_MESSAGE.REQUIRED_DOUBLE}`
          );
        }
        add[key] = val;
      });
    } else {
      by = by || 1;
      if (isNaN(parseFloat(by))) {
        throw new Error(
          `${PARAMS.PROPERTY_VALUE}${ERROR_MESSAGE.REQUIRED_DOUBLE}`
        );
      }

      if (!StringHelper.isValid(prop)) {
        StringHelper.raiseError(PARAMS.NAME);
      }

      add[prop] = by;
    }
    this.mixpanelImpl.increment(this.token, add);
  }

  /**
   * Appends a value to a list-valued property. If the property does not currently exist,
   * it will be created as a list of one element. If the property does exist and doesn't
   * currently have a list value, the append will be ignored.
   * @param {string} name the People Analytics property that should have it's value appended to
   * @param {object} value the new value that will appear at the end of the property's list
   */
  append(name, value) {
    let appendProp = {};
    if (!StringHelper.isValid(name)) {
      StringHelper.raiseError(PARAMS.NAME);
    } else {
      appendProp[name] = value;
    }

    if (DevicePlatform.iOS === Helper.getDevicePlatform()) {
      this.mixpanelImpl.append(this.token, appendProp);
    } else {
      this.mixpanelImpl.append(this.token, name, value);
    }
  }

  /**
   * Adds values to a list-valued property only if they are not already present in the list.
   * If the property does not currently exist, it will be created with the given list as it's value.
   * If the property exists and is not list-valued, the union will be ignored.
   *
   * @param {string} name name of the list-valued property to set or modify
   * @param {array} value an array of values to add to the property value if not already present
   */
  union(name, value) {
    if (!StringHelper.isValid(name)) {
      StringHelper.raiseError(PARAMS.NAME);
    }

    value = Array.isArray(value) ? value : [value];

    if (DevicePlatform.iOS === Helper.getDevicePlatform()) {
      this.mixpanelImpl.union(this.token, {[name]: value});
      this.mixpanelImpl.union(this.token, {[name]: value});
    } else {
      this.mixpanelImpl.union(this.token, name, value);
    }
  }

  /**
   * Remove value from a list-valued property only if they are already present in the list.
   * If the property does not currently exist, the remove will be ignored.
   * If the property exists and is not list-valued, the remove will be ignored.
   * @param {string} name the People Analytics property that should have it's value removed from
   * @param {object} value the value that will be removed from the property's list
   */
  remove(name, value) {
    let removeProp = {};
    if (!StringHelper.isValid(name)) {
      StringHelper.raiseError(PARAMS.NAME);
    } else {
      removeProp[name] = value;
    }

    if (DevicePlatform.iOS === Helper.getDevicePlatform()) {
      this.mixpanelImpl.remove(this.token, removeProp);
    } else {
      this.mixpanelImpl.remove(this.token, name, value);
    }
  }

  /**
   * permanently removes the property with the given name from the user's profile
   * @param {string} name name of a property to unset
   */
  unset(name) {
    if (!StringHelper.isValid(name)) {
      StringHelper.raiseError(PARAMS.PROPERTY_NAME);
    }
    this.mixpanelImpl.unset(this.token, name);
  }

  /**
   * Track a revenue transaction for the identified people profile.
   *
   * @param {number} charge the amount of money exchanged. Positive amounts represent purchases or income from the customer, negative amounts represent refunds or payments to the customer.
   * @param {object} properties an optional collection of properties to associate with this transaction.
   */
  trackCharge(charge, properties) {
    if (isNaN(parseFloat(charge))) {
      throw new Error(`${PARAMS.CHARGE}${ERROR_MESSAGE.REQUIRED_DOUBLE}`);
    }

    if (!ObjectHelper.isValidOrUndefined(properties)) {
      ObjectHelper.raiseError(PARAMS.PROPERTIES);
    }
    this.mixpanelImpl.trackCharge(this.token, charge, properties || {});
  }

  /**
   * Permanently clear the whole transaction history for the identified people profile.
   */
  clearCharges() {
    this.mixpanelImpl.clearCharges(this.token);
  }

  /**
   * Permanently deletes the identified user's record from People Analytics.
   *
   * <p>Calling deleteUser deletes an entire record completely. Any future calls
   * to People Analytics using the same distinct id will create and store new values.
   */
  deleteUser() {
    this.mixpanelImpl.deleteUser(this.token);
  }
}

/**
 * Core class for using Mixpanel Group Analytics features.
 *
 * <p>The MixpanelGroup object is used to update properties in a group's Group Analytics record.
 */
export class MixpanelGroup {
  constructor(token, groupKey, groupID, mixpanelImpl) {
    if (!StringHelper.isValid(token)) {
      StringHelper.raiseError(PARAMS.TOKEN);
    }
    this.token = token;
    this.groupKey = groupKey;
    this.groupID = groupID;
    this.mixpanelImpl = mixpanelImpl;
  }

  /**
   * Sets a single property with the given name and value for this group.
   * The given name and value will be assigned to the user in Mixpanel Group Analytics,
   * possibly overwriting an existing property with the same name.
   *
   * @param {string} prop The name of the Mixpanel property. This must be a String, for example "Zip Code"
   * @param {string} to The value to set on the given property name. For "Zip Code", this value might be the String "90210"
   */
  set(prop, to) {
    let properties = {};
    if (ObjectHelper.isValid(prop)) {
      properties = JSON.parse(JSON.stringify(prop || {}));
    } else {
      if (!StringHelper.isValid(prop)) {
        StringHelper.raiseError(PARAMS.PROP);
      }
      properties[prop] = to;
    }
    this.mixpanelImpl.groupSetProperties(
      this.token,
      this.groupKey,
      this.groupID,
      properties
    );
  }

  /**
   * Works just like groupSet() except it will not overwrite existing property values. This is useful for properties like "First login date".
   *
   * @param {string} prop The name of the Mixpanel property. This must be a String, for example "Zip Code"
   * @param {string} to The value to set on the given property name. For "Zip Code", this value might be the String "90210"
   */
  setOnce(prop, to) {
    let properties = {};
    if (ObjectHelper.isValid(prop)) {
      properties = JSON.parse(JSON.stringify(prop || {}));
    } else {
      if (!StringHelper.isValid(prop)) {
        StringHelper.raiseError(PARAMS.PROP);
      }
      properties[prop] = to;
    }
    this.mixpanelImpl.groupSetPropertyOnce(
      this.token,
      this.groupKey,
      this.groupID,
      properties
    );
  }

  /**
   * Permanently removes the property with the given name from the group's profile
   *
   * @param {string} prop name of a property to unset
   */
  unset(prop) {
    if (!StringHelper.isValid(prop)) {
      StringHelper.raiseError(PARAMS.PROPERTY_NAME);
    }
    this.mixpanelImpl.groupUnsetProperty(
      this.token,
      this.groupKey,
      this.groupID,
      prop
    );
  }

  /**
   * Remove value from a list-valued property only if it is already present in the list.
   * If the property does not currently exist, the remove will be ignored.
   * If the property exists and is not list-valued, the remove will be ignored.
   *
   * @param {string} name the Group Analytics list-valued property that should have a value removed
   * @param {any} value the value that will be removed from the list
   */
  remove(name, value) {
    if (!StringHelper.isValid(name)) {
      StringHelper.raiseError(PARAMS.PROPERTY_NAME);
    }

    this.mixpanelImpl.groupRemovePropertyValue(
      this.token,
      this.groupKey,
      this.groupID,
      name,
      value
    );
  }

  /**
   * Adds values to a list-valued property only if they are not already present in the list.
   * If the property does not currently exist, it will be created with the given list as its value.
   * If the property exists and is not list-valued, the union will be ignored.
   *
   * @param {string} name name of the list-valued property to set or modify
   * @param {array} value an array of values to add to the property value if not already present
   */
  union(name, value) {
    if (!StringHelper.isValid(name)) {
      StringHelper.raiseError(PARAMS.PROPERTY_NAME);
    }
    value = Array.isArray(value) ? value : [value];
    this.mixpanelImpl.groupUnionProperty(
      this.token,
      this.groupKey,
      this.groupID,
      name,
      value
    );
  }
}

class Helper {
  /**
      Get the library data from package.json file.
     */
  static getMetaData() {
    let metadata = JSON.parse(JSON.stringify(packageJson.metadata));
    metadata["$lib_version"] = packageJson.version;
    return metadata;
  }

  /**
      Get current device platform.
     */
  static getDevicePlatform() {
    switch (Platform.OS) {
      case "android":
        return DevicePlatform.Android;
      case "ios":
        return DevicePlatform.iOS;
      default:
        return DevicePlatform.Unknown;
    }
  }
}

class StringHelper {
  /**
      Check whether the parameter is not a blank string.
     */
  static isValid(str) {
    return typeof str === "string" && !/^\s*$/.test(str);
  }

  /**
      Check whether the parameter is undefined or not a blank string.
     */
  static isValidOrUndefined(str) {
    return str === undefined || StringHelper.isValid(str);
  }

  /**
      Raise a string validation error.
     */
  static raiseError(paramName) {
    throw new Error(`${paramName}${ERROR_MESSAGE.INVALID_STRING}`);
  }
}

class ObjectHelper {
  /**
      Check whether the parameter is an object.
     */
  static isValid(obj) {
    return typeof obj === "object";
  }

  /**
      Check whether the parameter is undefined or an object.
     */
  static isValidOrUndefined(obj) {
    return obj === undefined || ObjectHelper.isValid(obj);
  }

  /**
      Raise an object validation error.
     */
  static raiseError(paramName) {
    throw new Error(`${paramName}${ERROR_MESSAGE.INVALID_OBJECT}`);
  }
}