mixpanel-react-native 3.0.9 → 3.1.0

package/Samples/MixpanelExpo/.yalc/mixpanel-react-native/javascript/mixpanel-persistent.js

@@ -0,0 +1,328 @@
+import {
+  getDeviceIdKey,
+  getDistinctIdKey,
+  getSuperPropertiesKey,
+  getTimeEventsKey,
+  getOptedOutKey as getOutedOutKey,
+  getQueueKey,
+  getUserIdKey,
+  getAppHasOpenedBeforeKey,
+} from "./mixpanel-constants";
+
+import { AsyncStorageAdapter } from "./mixpanel-storage";
+import uuid from "uuid";
+import { MixpanelLogger } from "mixpanel-react-native/javascript/mixpanel-logger";
+import { randomUUID } from "expo-crypto";
+
+export class MixpanelPersistent {
+  static instance;
+
+  static getInstance(storage, token) {
+    if (!MixpanelPersistent.instance) {
+      MixpanelPersistent.instance = new MixpanelPersistent(
+        new AsyncStorageAdapter(storage)
+      );
+      MixpanelPersistent.initializationCompletePromise =
+        MixpanelPersistent.instance.initializationCompletePromise(token);
+    }
+    return MixpanelPersistent.instance;
+  }
+
+  constructor(storageAdapter) {
+    if (MixpanelPersistent.instance) {
+      throw new Error(`Use MixpanelPersistent.getInstance()`);
+    }
+
+    this.storageAdapter = storageAdapter;
+    this._superProperties = {};
+    this._timeEvents = {};
+    this._identity = {};
+    this._optedOut = {};
+    this._appHasOpenedBefore = {};
+  }
+
+  async initializationCompletePromise(token) {
+    Promise.all([
+      this.loadIdentity(token),
+      this.loadSuperProperties(token),
+      this.loadTimeEvents(token),
+      this.loadOptOut(token),
+      this.loadAppHasOpenedBefore(token),
+    ]);
+  }
+
+  async loadDeviceId(token) {
+    if (!token) {
+      return;
+    }
+
+    const storageToken = await this.storageAdapter.getItem(
+      getDeviceIdKey(token)
+    );
+
+    if (!this._identity[token]) {
+      this._identity[token] = {};
+    }
+
+    this._identity[token].deviceId = storageToken;
+
+    if (!this._identity[token].deviceId) {
+      try {
+        this._identity[token].deviceId = randomUUID();
+      } catch (e) {
+        this._identity[token].deviceId = uuid.v4();
+      }
+      await this.storageAdapter.setItem(
+        getDeviceIdKey(token),
+        this._identity[token].deviceId
+      );
+    }
+    MixpanelLogger.log(token, "deviceId:", this._identity[token].deviceId);
+  }
+
+  async loadDistinctId(token) {
+    await this.storageAdapter
+      .getItem(getDistinctIdKey(token))
+      .then((distinctId) => {
+        if (!this._identity[token]) {
+          this._identity[token] = {};
+        }
+        this._identity[token].distinctId = distinctId;
+      });
+    if (!this._identity[token].distinctId) {
+      this._identity[token].distinctId =
+        "$device:" + this._identity[token].deviceId;
+      await this.storageAdapter.setItem(
+        getDistinctIdKey(token),
+        this._identity[token].distinctId
+      );
+    }
+    MixpanelLogger.log(token, "distinctId:", this._identity[token].distinctId);
+  }
+
+  async loadUserId(token) {
+    await this.storageAdapter.getItem(getUserIdKey(token)).then((userId) => {
+      if (!this._identity[token]) {
+        this._identity[token] = {};
+      }
+      this._identity[token].userId = userId;
+    });
+    MixpanelLogger.log(token, "userId:", this._identity[token].userId);
+  }
+
+  async loadIdentity(token) {
+    await this.loadDeviceId(token);
+    await this.loadDistinctId(token);
+    await this.loadUserId(token);
+  }
+
+  async persistIdentity(token) {
+    await this.persistDeviceId(token);
+    await this.persistDistinctId(token);
+    await this.persistUserId(token);
+  }
+
+  getDeviceId(token) {
+    if (!this._identity[token]) {
+      return null;
+    }
+    return this._identity[token].deviceId;
+  }
+
+  updateDeviceId(token, deviceId) {
+    this._identity[token].deviceId = deviceId;
+  }
+
+  async persistDeviceId(token) {
+    if (!this._identity[token] || this._identity[token].deviceId === null) {
+      return;
+    }
+    await this.storageAdapter.setItem(
+      getDeviceIdKey(token),
+      this._identity[token].deviceId
+    );
+  }
+
+  getDistinctId(token) {
+    if (!this._identity[token]) {
+      return null;
+    }
+    return this._identity[token].distinctId;
+  }
+
+  updateDistinctId(token, distinctId) {
+    this._identity[token].distinctId = distinctId;
+  }
+
+  async persistDistinctId(token) {
+    if (!this._identity[token] || this._identity[token].distinctId === null) {
+      return;
+    }
+    await this.storageAdapter.setItem(
+      getDistinctIdKey(token),
+      this._identity[token].distinctId
+    );
+  }
+
+  getUserId(token) {
+    if (!this._identity[token]) {
+      return null;
+    }
+    return this._identity[token].userId;
+  }
+
+  isIdentified(token) {
+    const userId = this.getUserId(token);
+    const isIdentified = userId !== null && userId !== undefined;
+    return isIdentified;
+  }
+
+  updateUserId(token, userId) {
+    this._identity[token].userId = userId;
+  }
+
+  async persistUserId(token) {
+    if (!this._identity[token] || this._identity[token].userId === null) {
+      return;
+    }
+    await this.storageAdapter.setItem(
+      getUserIdKey(token),
+      this._identity[token].userId
+    );
+  }
+
+  async loadSuperProperties(token) {
+    const superPropertiesString = await this.storageAdapter.getItem(
+      getSuperPropertiesKey(token)
+    );
+    this._superProperties[token] = superPropertiesString
+      ? JSON.parse(superPropertiesString)
+      : {};
+  }
+
+  getSuperProperties(token) {
+    return this._superProperties[token];
+  }
+
+  updateSuperProperties(token, superProperties) {
+    this._superProperties = {
+      ...this._superProperties,
+      [token]: { ...superProperties },
+    };
+  }
+
+  async persistSuperProperties(token) {
+    if (this._superProperties[token] === null) {
+      return;
+    }
+    await this.storageAdapter.setItem(
+      getSuperPropertiesKey(token),
+      JSON.stringify(this._superProperties[token])
+    );
+  }
+
+  async loadTimeEvents(token) {
+    const timeEventsString = await this.storageAdapter.getItem(
+      getTimeEventsKey(token)
+    );
+    this._timeEvents[token] = timeEventsString
+      ? JSON.parse(timeEventsString)
+      : {};
+  }
+
+  getTimeEvents(token) {
+    return this._timeEvents[token];
+  }
+
+  updateTimeEvents(token, timeEvents) {
+    this._timeEvents = { ...this._timeEvents, [token]: { ...timeEvents } };
+  }
+
+  async persistTimeEvents(token) {
+    if (this._timeEvents[token] === null) {
+      return;
+    }
+    await this.storageAdapter.setItem(
+      getTimeEventsKey(token),
+      JSON.stringify(this._timeEvents[token])
+    );
+  }
+
+  async loadOptOut(token) {
+    const optOutString = await this.storageAdapter.getItem(
+      getOutedOutKey(token)
+    );
+    this._optedOut[token] = optOutString === "true";
+  }
+
+  getOptedOut(token) {
+    return this._optedOut[token] === true;
+  }
+
+  updateOptedOut(token, optOut) {
+    this._optedOut = { ...this._optedOut, [token]: optOut };
+  }
+
+  async persistOptedOut(token) {
+    if (this._optedOut[token] === null) {
+      return;
+    }
+    await this.storageAdapter.setItem(
+      getOutedOutKey(token),
+      this._optedOut[token].toString()
+    );
+  }
+
+  async loadQueue(token, type) {
+    const queueString = await this.storageAdapter.getItem(
+      getQueueKey(token, type)
+    );
+    return queueString ? JSON.parse(queueString) : [];
+  }
+
+  async saveQueue(token, type, queue) {
+    await this.storageAdapter.setItem(
+      getQueueKey(token, type),
+      JSON.stringify(queue)
+    );
+  }
+
+  async loadAppHasOpenedBefore(token) {
+    const appHasOpenedBeforeString = await this.storageAdapter.getItem(
+      getAppHasOpenedBeforeKey(token)
+    );
+    this._appHasOpenedBefore[token] = appHasOpenedBeforeString === "true";
+  }
+
+  getAppHasOpenedBefore(token) {
+    return this._appHasOpenedBefore[token] === true;
+  }
+
+  updateAppHasOpenedBefore(token, appHasOpenedBefore) {
+    this._appHasOpenedBefore = {
+      ...this._appHasOpenedBefore,
+      [token]: appHasOpenedBefore,
+    };
+  }
+
+  async persistAppHasOpenedBefore(token) {
+    if (this._appHasOpenedBefore[token] === null) {
+      return;
+    }
+    await this.storageAdapter.setItem(
+      getAppHasOpenedBeforeKey(token),
+      this._appHasOpenedBefore[token].toString()
+    );
+  }
+
+  async reset(token) {
+    await this.storageAdapter.removeItem(getDeviceIdKey(token));
+    await this.storageAdapter.removeItem(getDistinctIdKey(token));
+    await this.storageAdapter.removeItem(getUserIdKey(token));
+    await this.storageAdapter.removeItem(getSuperPropertiesKey(token));
+    await this.storageAdapter.removeItem(getTimeEventsKey(token));
+    await this.loadIdentity(token);
+    await this.loadSuperProperties(token);
+    await this.loadTimeEvents(token);
+  }
+}

package/Samples/MixpanelExpo/.yalc/mixpanel-react-native/javascript/mixpanel-queue.js

@@ -0,0 +1,117 @@
+import { MixpanelLogger } from "./mixpanel-logger";
+import { MixpanelPersistent } from "./mixpanel-persistent";
+import { MixpanelType } from "./mixpanel-constants";
+
+export const MixpanelQueueManager = (() => {
+  let _queues = {};
+  let mixpanelPersistent;
+
+  const getPersistent = () => {
+    if (!mixpanelPersistent) {
+      mixpanelPersistent = MixpanelPersistent.getInstance();
+    }
+    return mixpanelPersistent;
+  };
+
+  const initialize = async (token, type) => {
+    if (!_queues[token] || !_queues[token][type]) {
+      const queue = await getPersistent().loadQueue(token, type);
+      _queues[token] = {
+        ..._queues[token],
+        [type]: queue,
+      };
+    }
+  };
+
+  const updateQueueInStorage = async (token, type) => {
+    if (!_queues[token] || !_queues[token][type]) {
+      return;
+    }
+    await getPersistent().saveQueue(token, type, _queues[token][type]);
+  };
+
+  const enqueue = async (token, type, data) => {
+    if (!_queues[token] || !_queues[token][type]) {
+      _queues[token] = {
+        ..._queues[token],
+        [type]: [],
+      };
+    }
+    _queues[token][type].push(data);
+    await updateQueueInStorage(token, type);
+  };
+
+  const getQueue = (token, type) => {
+    if (
+      !_queues[token] ||
+      !_queues[token][type] ||
+      (type === MixpanelType.USER && !getPersistent().isIdentified(token))
+    ) {
+      return [];
+    }
+
+    return [..._queues[token][type]];
+  };
+
+  const spliceQueue = async (token, type, start, deleteCount) => {
+    if (!_queues[token] || !_queues[token][type]) {
+      return;
+    }
+    _queues[token][type].splice(start, deleteCount);
+    await updateQueueInStorage(token, type);
+  };
+
+  const clearQueue = async (token, type) => {
+    if (!_queues[token] || !_queues[token][type]) {
+      return;
+    }
+    _queues[token][type] = [];
+    await updateQueueInStorage(token, type);
+  };
+
+  /**
+   * Ensures all USER queue records for the given token have the correct identity fields.
+   * Returns the updated queue (may be unchanged).
+   */
+  const identifyUserQueue = async (token) => {
+    const persistent = getPersistent();
+    const distinctId = persistent.getDistinctId(token);
+    const deviceId = persistent.getDeviceId(token);
+    const userId = persistent.getUserId(token);
+
+    const userQueue = _queues[token]?.[MixpanelType.USER];
+    if (!userQueue) return [];
+
+    let changed = false;
+    const updatedQueue = userQueue.map(record => {
+      let updated = record;
+      const updateDistinctId = distinctId != null && record.$distinct_id !== distinctId;
+      const updateDeviceId = deviceId != null && record.$device_id !== deviceId;
+      const updateUserId = userId != null && record.$user_id !== userId;
+      // Only update if there is a difference; minimize object copies
+      if (updateDistinctId || updateDeviceId || updateUserId) {
+        updated = { ...record }; // shallow copy only if needed
+        if (updateDistinctId) updated.$distinct_id = distinctId;
+        if (updateDeviceId) updated.$device_id = deviceId;
+        if (updateUserId) updated.$user_id = userId;
+        changed = true;
+      }
+      return updated;
+    });
+
+    if (changed) {
+      _queues[token][MixpanelType.USER] = updatedQueue;
+      await persistent.saveQueue(token, MixpanelType.USER, updatedQueue);
+    }
+    return updatedQueue;
+  };
+
+  return {
+    initialize,
+    enqueue,
+    getQueue,
+    spliceQueue,
+    clearQueue,
+    identifyUserQueue,
+  };
+})();

package/Samples/MixpanelExpo/.yalc/mixpanel-react-native/javascript/mixpanel-storage.js

@@ -0,0 +1,67 @@
+import {MixpanelLogger} from "mixpanel-react-native/javascript/mixpanel-logger";
+
+export class AsyncStorageAdapter {
+  constructor(storage) {
+    if (!storage) {
+      try {
+        const storageModule = require("@react-native-async-storage/async-storage");
+        if (storageModule.default) {
+          this.storage = storageModule.default
+        } else {
+          this.storage = storageModule
+        }
+      } catch {
+        console.error(
+          "[@RNC/AsyncStorage]: NativeModule: AsyncStorage is null. Please run 'npm install @react-native-async-storage/async-storage' or follow the Mixpanel guide to set up your own Storage class."
+        );
+        console.error("[Mixpanel] Falling back to in-memory storage");
+        this.storage = new InMemoryStorage();
+      }
+    } else {
+      this.storage = storage;
+    }
+  }
+
+  async getItem(key) {
+    try {
+      return await this.storage.getItem(key);
+    } catch {
+      MixpanelLogger.error("error getting item from storage");
+      return null;
+    }
+  }
+
+  async setItem(key, value) {
+    try {
+      await this.storage.setItem(key, value);
+    } catch {
+      MixpanelLogger.error("error setting item in storage");
+    }
+  }
+
+  async removeItem(key) {
+    try {
+      await this.storage.removeItem(key);
+    } catch {
+      MixpanelLogger.error("error removing item from storage");
+    }
+  }
+}
+
+class InMemoryStorage {
+  constructor() {
+    this.store = {};
+  }
+
+  async getItem(key) {
+    return this.store.hasOwnProperty(key) ? this.store[key] : null;
+  }
+
+  async setItem(key, value) {
+    this.store[key] = value;
+  }
+
+  async removeItem(key) {
+    delete this.store[key];
+  }
+}

package/Samples/MixpanelExpo/.yalc/mixpanel-react-native/javascript/mixpanel-utils.js

@@ -0,0 +1,38 @@
+import {MixpanelType} from "mixpanel-react-native/javascript/mixpanel-constants";
+
+export class SessionMetadata {
+  constructor(trackingQueue) {
+    this.eventsCounter = 0;
+    this.peopleCounter = 0;
+    this.sessionID = SessionMetadata.randomId();
+    this.sessionStartEpoch = Math.round(Date.now() / 1000);
+    this.trackingQueue = trackingQueue;
+  }
+
+  static randomId() {
+    return (
+      Math.floor(Math.random() * (1 << 30)).toString(16) +
+      Math.floor(Math.random() * (1 << 30)).toString(16)
+    ).padStart(16, "0");
+  }
+
+  toDict(type) {
+    const dict = {
+      $mp_metadata: {
+        $mp_event_id: SessionMetadata.randomId(),
+        $mp_session_id: this.sessionID,
+        $mp_session_seq_id:
+          type === MixpanelType.EVENTS
+            ? this.eventsCounter
+            : this.peopleCounter,
+        $mp_session_start_sec: this.sessionStartEpoch,
+      },
+    };
+    if (type === MixpanelType.EVENTS) {
+      this.eventsCounter += 1;
+    } else {
+      this.peopleCounter += 1;
+    }
+    return dict;
+  }
+}

package/Samples/MixpanelExpo/.yalc/mixpanel-react-native/package.json

@@ -0,0 +1,55 @@
+{
+  "name": "mixpanel-react-native",
+  "version": "3.0.9",
+  "description": "Official React Native Tracking Library for Mixpanel Analytics",
+  "main": "index.js",
+  "scripts": {
+    "test": "jest"
+  },
+  "author": "Mixpanel",
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/mixpanel/mixpanel-react-native.git"
+  },
+  "keywords": [
+    "mixpanel",
+    "react",
+    "native",
+    "ios",
+    "android",
+    "analytics",
+    "tracking",
+    "sdk"
+  ],
+  "bugs": {
+    "url": "https://github.com/mixpanel/mixpanel-react-native/issues"
+  },
+  "TODO": "Change the git URL before publishing on npm",
+  "homepage": "https://github.com/mixpanel/mixpanel-react-native#readme",
+  "metadata": {
+    "mp_lib": "react-native"
+  },
+  "jest": {
+    "modulePathIgnorePatterns": [
+      "<rootDir>/Samples/"
+    ],
+    "testMatch": [
+      "<rootDir>/__tests__/*.test.js"
+    ],
+    "setupFiles": [
+      "<rootDir>/__tests__/jest_setup.js"
+    ],
+    "verbose": true,
+    "preset": "react-native",
+    "transform": {
+      "^.+\\.js$": "<rootDir>/node_modules/react-native/jest/preprocessor.js"
+    }
+  },
+  "dependencies": {
+    "@react-native-async-storage/async-storage": "^1.21.0",
+    "expo-crypto": "~14.1.4",
+    "uuid": "3.3.2"
+  },
+  "yalcSig": "a70b7359f0f86a46e69a2d9e9c657fcf"
+}

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

@@ -0,0 +1,19 @@
+'use strict';
+
+module.exports = {
+  dependencies: {
+    'mixpanel-react-native': {
+      platforms: {
+        android: {
+          "sourceDir": "./node_modules/mixpanel-react-native/android",
+          "folder": "./node_modules/mixpanel-react-native",
+          "packageImportPath": "import com.mixpanel.reactnative.MixpanelReactNativePackage;",
+          "packageInstance": "new MixpanelReactNativePackage()"
+        },
+        ios: {
+          project: './node_modules/mixpanel-react-native/ios/MixpanelReactNative.xcodeproj',
+        }
+      }
+    }
+  }
+};

package/Samples/MixpanelExpo/.yalc/mixpanel-react-native/release.py

@@ -0,0 +1,50 @@
+
+import argparse
+import subprocess
+
+
+parser = argparse.ArgumentParser(description='Release Mixpanel React Native SDK')
+parser.add_argument('--old', help='version for the release', action="store")
+parser.add_argument('--new', help='version for the release', action="store")
+args = parser.parse_args()
+
+def bump_version():
+    replace_version('package.json', "\"version\": \"" + args.old + "\"", "\"version\": \"" + args.new + "\"")
+    subprocess.call('rm -fr node_modules', shell=True)
+    subprocess.call('cd Samples/MixpanelDemo;rm -fr node_modules;rm -fr android/app/build;rm -fr ios/Pods', shell=True)
+    subprocess.call('cd Samples/SimpleMixpanel;rm -fr node_modules;rm -fr android/app/build;rm -fr ios/Pods', shell=True)
+    subprocess.call('cd Samples/ContextAPIMixpanel;rm -fr node_modules;rm -fr android/app/build;rm -fr ios/Pods', shell=True)
+    subprocess.call('cd Samples/MixpanelExpo;rm -fr node_modules', shell=True)
+    subprocess.call('git add package.json', shell=True)
+    subprocess.call('git add __tests__/index.test.js', shell=True)
+
+    subprocess.call('git commit -m "Version {}"'.format(args.new), shell=True)
+    subprocess.call('git push', shell=True)
+
+def replace_version(file_name, old_version, new_version):
+    with open(file_name) as f:
+        file_str = f.read()
+        assert(old_version in file_str)
+        file_str = file_str.replace(old_version, new_version)
+
+    with open(file_name, "w") as f:
+        f.write(file_str)
+
+def generate_docs():
+    subprocess.call('./generate_docs.sh', shell=True)
+    subprocess.call('git add docs', shell=True)
+    subprocess.call('git commit -m "Update docs"', shell=True)
+    subprocess.call('git push', shell=True)
+
+def add_tag():
+    subprocess.call('git tag -a v{} -m "version {}"'.format(args.new, args.new), shell=True)
+    subprocess.call('git push origin --tags', shell=True)
+
+def main():
+    bump_version()
+    generate_docs()
+    add_tag()
+    print("Congratulations! " + args.new + " is now released!")
+
+if __name__ == '__main__':
+    main()

package/Samples/MixpanelExpo/.yalc/mixpanel-react-native/yalc.sig

@@ -0,0 +1 @@
+a70b7359f0f86a46e69a2d9e9c657fcf