mixpanel-react-native 3.0.9 → 3.1.0

package/Samples/MixpanelExpo/.yalc/mixpanel-react-native/Samples/MixpanelExpo/.yalc/mixpanel-react-native/Samples/MixpanelExpo/.yalc/mixpanel-react-native/index.js

@@ -0,0 +1,996 @@
+"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 && MixpanelReactNative) {
+      this.mixpanelImpl = MixpanelReactNative;
+      return;
+    } else if (useNative) {
+      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);
+  }
+
+  /**
+   * 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}`);
+  }
+}