@amplitude/analytics-react-native 0.0.1-dev.4 → 0.0.1-dev.7

package/src/attribution/campaign-parser.ts

@@ -1,78 +0,0 @@
-import { UTMCookie } from '../storage/utm-cookie';
-import { getQueryParams } from '../utils/query-params';
-import {
-  UTM_CAMPAIGN,
-  UTM_CONTENT,
-  UTM_MEDIUM,
-  UTM_SOURCE,
-  UTM_TERM,
-  UTMZ_SOURCE,
-  UTMZ_MEDIUM,
-  UTMZ_CAMPAIGN,
-  UTMZ_TERM,
-  UTMZ_CONTENT,
-  GCLID,
-  FBCLID,
-  BASE_CAMPAIGN,
-} from './constants';
-import {
-  Campaign,
-  CampaignParser as ICampaignParser,
-  ClickIdParameters,
-  ReferrerParameters,
-  UTMParameters,
-} from '@amplitude/analytics-types';
-
-export class CampaignParser implements ICampaignParser {
-  utmCookieStorage = new UTMCookie();
-
-  async parse(): Promise<Campaign> {
-    return {
-      ...BASE_CAMPAIGN,
-      ...(await this.getUtmParam()),
-      ...this.getReferrer(),
-      ...this.getClickIds(),
-    } as Campaign;
-  }
-
-  async getUtmParam(): Promise<UTMParameters> {
-    const params = getQueryParams();
-    const cookies = ((await this.utmCookieStorage.isEnabled()) && (await this.utmCookieStorage.get('__utmz'))) || {};
-
-    const utmSource = params[UTM_SOURCE] || cookies[UTMZ_SOURCE];
-    const utmMedium = params[UTM_MEDIUM] || cookies[UTMZ_MEDIUM];
-    const utmCampaign = params[UTM_CAMPAIGN] || cookies[UTMZ_CAMPAIGN];
-    const utmTerm = params[UTM_TERM] || cookies[UTMZ_TERM];
-    const utmContent = params[UTM_CONTENT] || cookies[UTMZ_CONTENT];
-
-    return {
-      utm_source: utmSource,
-      utm_medium: utmMedium,
-      utm_campaign: utmCampaign,
-      utm_term: utmTerm,
-      utm_content: utmContent,
-    };
-  }
-
-  getReferrer(): ReferrerParameters {
-    const data: ReferrerParameters = {
-      referrer: undefined,
-      referring_domain: undefined,
-    };
-    try {
-      data.referrer = document.referrer || undefined;
-      data.referring_domain = data.referrer?.split('/')[2] ?? undefined;
-    } catch {
-      // nothing to track
-    }
-    return data;
-  }
-
-  getClickIds(): ClickIdParameters {
-    const params = getQueryParams();
-    return {
-      [GCLID]: params[GCLID],
-      [FBCLID]: params[FBCLID],
-    };
-  }
-}

package/src/attribution/campaign-tracker.ts

@@ -1,112 +0,0 @@
-import { createIdentifyEvent, Identify } from '@amplitude/analytics-core';
-import {
-  Storage,
-  Campaign,
-  CampaignParser as ICampaignParser,
-  CampaignTracker as ICampaignTracker,
-  CampaignTrackFunction,
-  CampaignTrackerOptions,
-  BaseEvent,
-} from '@amplitude/analytics-types';
-import { getCookieName as getStorageKey } from '../utils/cookie-name';
-import { CampaignParser } from './campaign-parser';
-import { BASE_CAMPAIGN, EMPTY_VALUE, MKTG } from './constants';
-
-export class CampaignTracker implements ICampaignTracker {
-  storage: Storage<Campaign>;
-  storageKey: string;
-  parser: ICampaignParser;
-  track: CampaignTrackFunction;
-  onNewCampaign: (campaign: Campaign) => unknown;
-
-  disabled: boolean;
-  trackNewCampaigns: boolean;
-  trackPageViews: boolean;
-  excludeReferrers: string[];
-  initialEmptyValue: string;
-
-  constructor(apiKey: string, options: CampaignTrackerOptions) {
-    this.storage = options.storage;
-    this.storageKey = getStorageKey(apiKey, MKTG);
-    this.parser = new CampaignParser();
-    this.track = options.track;
-    this.onNewCampaign = options.onNewCampaign;
-
-    this.disabled = Boolean(options.disabled);
-    this.trackNewCampaigns = Boolean(options.trackNewCampaigns);
-    this.trackPageViews = options.trackPageViews === undefined || Boolean(options.trackPageViews);
-    this.excludeReferrers = options.excludeReferrers ?? [];
-    if (typeof location !== 'undefined') {
-      this.excludeReferrers.unshift(location.hostname);
-    }
-    this.initialEmptyValue = options.initialEmptyValue ?? EMPTY_VALUE;
-  }
-
-  isNewCampaign(currentCampaign: Campaign, previousCampaign: Campaign) {
-    const isReferrerExcluded = Boolean(
-      currentCampaign.referring_domain && this.excludeReferrers.includes(currentCampaign.referring_domain),
-    );
-    const hasNewUtm =
-      previousCampaign.utm_campaign !== currentCampaign.utm_campaign ||
-      previousCampaign.utm_source !== currentCampaign.utm_source ||
-      previousCampaign.utm_medium !== currentCampaign.utm_medium ||
-      previousCampaign.utm_term !== currentCampaign.utm_term ||
-      previousCampaign.utm_content !== currentCampaign.utm_content;
-    const hasNewReferrer = previousCampaign.referring_domain !== currentCampaign.referring_domain;
-
-    return !isReferrerExcluded && (hasNewUtm || hasNewReferrer);
-  }
-
-  async saveCampaignToStorage(campaign: Campaign): Promise<void> {
-    await this.storage.set(this.storageKey, campaign);
-  }
-
-  async getCampaignFromStorage(): Promise<Campaign> {
-    return (await this.storage.get(this.storageKey)) || { ...BASE_CAMPAIGN };
-  }
-
-  createCampaignEvent(campaign: Campaign) {
-    const campaignParameters: Campaign = {
-      // This object definition allows undefined keys to be iterated on
-      // in .reduce() to build indentify object
-      ...BASE_CAMPAIGN,
-      ...campaign,
-    };
-    const identifyEvent = Object.entries(campaignParameters).reduce((identify, [key, value]) => {
-      identify.setOnce(`initial_${key}`, value || this.initialEmptyValue);
-      if (value) {
-        return identify.set(key, value);
-      }
-      return identify.unset(key);
-    }, new Identify());
-
-    const pageViewEvent: BaseEvent = {
-      event_type: 'Page View',
-      event_properties: {
-        page_title: /* istanbul ignore next */ (typeof document !== 'undefined' && document.title) || '',
-        page_location: /* istanbul ignore next */ (typeof location !== 'undefined' && location.href) || '',
-        page_path: /* istanbul ignore next */ (typeof location !== 'undefined' && location.pathname) || '',
-      },
-    };
-    return {
-      ...createIdentifyEvent(identifyEvent),
-      ...(this.trackPageViews && pageViewEvent),
-    };
-  }
-
-  async send(isNewSession: boolean) {
-    if (this.disabled) {
-      return;
-    }
-    const currentCampaign = await this.parser.parse();
-    const previousCampaign = await this.getCampaignFromStorage();
-    if (!isNewSession) {
-      if (!this.trackNewCampaigns || !this.isNewCampaign(currentCampaign, previousCampaign)) {
-        return;
-      }
-      this.onNewCampaign(currentCampaign);
-    }
-    await this.track(this.createCampaignEvent(currentCampaign));
-    await this.saveCampaignToStorage(currentCampaign);
-  }
-}

package/src/attribution/constants.ts

@@ -1,32 +0,0 @@
-import { Campaign } from '@amplitude/analytics-types';
-
-export const UTM_SOURCE = 'utm_source';
-export const UTM_MEDIUM = 'utm_medium';
-export const UTM_CAMPAIGN = 'utm_campaign';
-export const UTM_TERM = 'utm_term';
-export const UTM_CONTENT = 'utm_content';
-
-export const UTMZ_SOURCE = 'utmcsr';
-export const UTMZ_MEDIUM = 'utmcmd';
-export const UTMZ_CAMPAIGN = 'utmccn';
-export const UTMZ_TERM = 'utmctr';
-export const UTMZ_CONTENT = 'utmcct';
-
-export const GCLID = 'gclid';
-export const FBCLID = 'fbclid';
-
-export const EMPTY_VALUE = 'EMPTY';
-
-export const BASE_CAMPAIGN: Campaign = {
-  utm_source: undefined,
-  utm_medium: undefined,
-  utm_campaign: undefined,
-  utm_term: undefined,
-  utm_content: undefined,
-  referrer: undefined,
-  referring_domain: undefined,
-  gclid: undefined,
-  fbclid: undefined,
-};
-
-export const MKTG = 'MKTG';

package/src/config.ts

@@ -1,240 +0,0 @@
-import {
-  Event,
-  ReactNativeOptions,
-  ReactNativeConfig as IReactNativeConfig,
-  Storage,
-  TrackingOptions,
-  TransportType,
-  UserSession,
-  SessionManager as ISessionManager,
-} from '@amplitude/analytics-types';
-import { Config, MemoryStorage, UUID } from '@amplitude/analytics-core';
-
-import { CookieStorage } from './storage/cookie';
-import { FetchTransport } from './transports/fetch';
-import { LocalStorage } from './storage/local-storage';
-import { getCookieName } from './utils/cookie-name';
-import { getQueryParams } from './utils/query-params';
-import { XHRTransport } from './transports/xhr';
-import { SendBeaconTransport } from './transports/send-beacon';
-import { SessionManager } from './session-manager';
-
-export const getDefaultConfig = () => {
-  const cookieStorage = new MemoryStorage<UserSession>();
-  return {
-    cookieExpiration: 365,
-    cookieSameSite: 'Lax',
-    cookieSecure: false,
-    cookieStorage,
-    disableCookies: false,
-    domain: '',
-    sessionManager: new SessionManager(cookieStorage, ''),
-    sessionTimeout: 30 * 60 * 1000,
-    storageProvider: new MemoryStorage<Event[]>(),
-    trackingOptions: {
-      city: true,
-      country: true,
-      carrier: true,
-      deviceManufacturer: true,
-      deviceModel: true,
-      dma: true,
-      ipAddress: true,
-      language: true,
-      osName: true,
-      osVersion: true,
-      platform: true,
-      region: true,
-      versionName: true,
-    },
-    transportProvider: new FetchTransport(),
-  };
-};
-
-export class ReactNativeConfig extends Config implements IReactNativeConfig {
-  appVersion?: string;
-  cookieExpiration: number;
-  cookieSameSite: string;
-  cookieSecure: boolean;
-  cookieStorage: Storage<UserSession>;
-  disableCookies: boolean;
-  domain: string;
-  partnerId?: string;
-  sessionTimeout: number;
-  trackingOptions: TrackingOptions;
-  sessionManager: ISessionManager;
-
-  constructor(apiKey: string, userId?: string, options?: ReactNativeOptions) {
-    const defaultConfig = getDefaultConfig();
-    super({
-      ...options,
-      apiKey,
-      storageProvider: options?.storageProvider ?? defaultConfig.storageProvider,
-      transportProvider: options?.transportProvider ?? defaultConfig.transportProvider,
-    });
-    this.cookieStorage = options?.cookieStorage ?? defaultConfig.cookieStorage;
-    this.sessionManager = options?.sessionManager ?? defaultConfig.sessionManager;
-    this.sessionTimeout = options?.sessionTimeout ?? defaultConfig.sessionTimeout;
-
-    this.appVersion = options?.appVersion;
-    this.cookieExpiration = options?.cookieExpiration ?? defaultConfig.cookieExpiration;
-    this.cookieSameSite = options?.cookieSameSite ?? defaultConfig.cookieSameSite;
-    this.cookieSecure = options?.cookieSecure ?? defaultConfig.cookieSecure;
-    this.deviceId = options?.deviceId;
-    this.disableCookies = options?.disableCookies ?? defaultConfig.disableCookies;
-    this.domain = options?.domain ?? defaultConfig.domain;
-    this.lastEventTime = this.lastEventTime ?? options?.lastEventTime;
-    this.optOut = Boolean(options?.optOut);
-    this.partnerId = options?.partnerId;
-    this.sessionId = options?.sessionId;
-    this.trackingOptions = options?.trackingOptions ?? defaultConfig.trackingOptions;
-    this.userId = userId;
-  }
-
-  get deviceId() {
-    return this.sessionManager.getDeviceId();
-  }
-
-  set deviceId(deviceId: string | undefined) {
-    this.sessionManager.setDeviceId(deviceId);
-  }
-
-  get userId() {
-    return this.sessionManager.getUserId();
-  }
-
-  set userId(userId: string | undefined) {
-    this.sessionManager.setUserId(userId);
-  }
-
-  get sessionId() {
-    return this.sessionManager.getSessionId();
-  }
-
-  set sessionId(sessionId: number | undefined) {
-    this.sessionManager.setSessionId(sessionId);
-  }
-
-  get optOut() {
-    return this.sessionManager.getOptOut();
-  }
-
-  set optOut(optOut: boolean) {
-    this.sessionManager?.setOptOut(Boolean(optOut));
-  }
-
-  get lastEventTime() {
-    return this.sessionManager.getLastEventTime();
-  }
-
-  set lastEventTime(lastEventTime: number | undefined) {
-    this.sessionManager.setLastEventTime(lastEventTime);
-  }
-}
-
-export const useReactNativeConfig = async (
-  apiKey: string,
-  userId?: string,
-  options?: ReactNativeOptions,
-): Promise<IReactNativeConfig> => {
-  const defaultConfig = getDefaultConfig();
-  const domain = options?.domain ?? (await getTopLevelDomain());
-  const cookieStorage = await createCookieStorage({ ...options, domain });
-  const cookieName = getCookieName(apiKey);
-  const cookies = await cookieStorage.get(cookieName);
-  const queryParams = getQueryParams();
-  const sessionManager = await new SessionManager(cookieStorage, apiKey).load();
-
-  return new ReactNativeConfig(apiKey, userId ?? cookies?.userId, {
-    ...options,
-    cookieStorage,
-    sessionManager,
-    deviceId: createDeviceId(cookies?.deviceId, options?.deviceId, queryParams.deviceId),
-    domain,
-    optOut: options?.optOut ?? Boolean(cookies?.optOut),
-    sessionId: (await cookieStorage.get(cookieName))?.sessionId ?? options?.sessionId,
-    storageProvider: await createEventsStorage(options),
-    trackingOptions: { ...defaultConfig.trackingOptions, ...options?.trackingOptions },
-    transportProvider: options?.transportProvider ?? createTransport(options?.transport),
-  });
-};
-
-export const createCookieStorage = async (
-  overrides?: ReactNativeOptions,
-  baseConfig = getDefaultConfig(),
-): Promise<Storage<UserSession>> => {
-  const options = { ...baseConfig, ...overrides };
-  const cookieStorage = overrides?.cookieStorage;
-  if (!cookieStorage || !(await cookieStorage.isEnabled())) {
-    return createFlexibleStorage<UserSession>(options);
-  }
-  return cookieStorage;
-};
-
-export const createFlexibleStorage = async <T>(options: ReactNativeOptions): Promise<Storage<T>> => {
-  let storage: Storage<T> = new CookieStorage({
-    domain: options.domain,
-    expirationDays: options.cookieExpiration,
-    sameSite: options.cookieSameSite,
-    secure: options.cookieSecure,
-  });
-  if (options.disableCookies || !(await storage.isEnabled())) {
-    storage = new LocalStorage();
-    if (!(await storage.isEnabled())) {
-      storage = new MemoryStorage();
-    }
-  }
-  return storage;
-};
-
-export const createEventsStorage = async (overrides?: ReactNativeOptions): Promise<Storage<Event[]>> => {
-  let eventsStorage = overrides?.storageProvider;
-  if (!eventsStorage || !(await eventsStorage.isEnabled())) {
-    eventsStorage = new LocalStorage();
-    if (!(await eventsStorage.isEnabled())) {
-      eventsStorage = new MemoryStorage();
-    }
-  }
-  return eventsStorage;
-};
-
-export const createDeviceId = (idFromCookies?: string, idFromOptions?: string, idFromQueryParams?: string) => {
-  return idFromOptions || idFromQueryParams || idFromCookies || UUID();
-};
-
-export const createTransport = (transport?: TransportType) => {
-  if (transport === TransportType.XHR) {
-    return new XHRTransport();
-  }
-  if (transport === TransportType.SendBeacon) {
-    return new SendBeaconTransport();
-  }
-  return getDefaultConfig().transportProvider;
-};
-
-export const getTopLevelDomain = async (url?: string) => {
-  if (!(await new CookieStorage<string>().isEnabled()) || (!url && typeof location === 'undefined')) {
-    return '';
-  }
-
-  const host = url ?? location.hostname;
-  const parts = host.split('.');
-  const levels = [];
-  const storageKey = 'AMP_TLDTEST';
-
-  for (let i = parts.length - 2; i >= 0; --i) {
-    levels.push(parts.slice(i).join('.'));
-  }
-  for (let i = 0; i < levels.length; i++) {
-    const domain = levels[i];
-    const options = { domain: '.' + domain };
-    const storage = new CookieStorage<number>(options);
-    await storage.set(storageKey, 1);
-    const value = await storage.get(storageKey);
-    if (value) {
-      await storage.remove(storageKey);
-      return '.' + domain;
-    }
-  }
-
-  return '';
-};

package/src/constants.ts

@@ -1,14 +0,0 @@
-export const UTM_SOURCE = 'utm_source';
-export const UTM_MEDIUM = 'utm_medium';
-export const UTM_CAMPAIGN = 'utm_campaign';
-export const UTM_TERM = 'utm_term';
-export const UTM_CONTENT = 'utm_content';
-
-export const UTMZ_SOURCE = 'utmcsr';
-export const UTMZ_MEDIUM = 'utmcmd';
-export const UTMZ_CAMPAIGN = 'utmccn';
-export const UTMZ_TERM = 'utmctr';
-export const UTMZ_CONTENT = 'utmcct';
-
-export const GCLID = 'gclid';
-export const FBCLID = 'fbclid';

package/src/cookie-migration/index.ts

@@ -1,54 +0,0 @@
-import { BrowserOptions, Storage, UserSession } from '@amplitude/analytics-types';
-import { getOldCookieName } from '../utils/cookie-name';
-import { LocalStorage } from '../storage/local-storage';
-import { CookieStorage } from '../storage/cookie';
-
-export const parseOldCookies = async (apiKey: string, options?: BrowserOptions): Promise<UserSession> => {
-  let storage: Storage<string> = new CookieStorage<string>();
-  if (!(await storage.isEnabled()) || options?.disableCookies) {
-    storage = new LocalStorage<string>();
-  }
-  if (!(await storage.isEnabled())) {
-    return {
-      optOut: false,
-    };
-  }
-
-  const oldCookieName = getOldCookieName(apiKey);
-  const cookies = await storage.getRaw(oldCookieName);
-
-  if (!cookies) {
-    return {
-      optOut: false,
-    };
-  }
-
-  await storage.remove(oldCookieName);
-  const [deviceId, userId, optOut, sessionId, lastEventTime] = cookies.split('.');
-  return {
-    deviceId,
-    userId: decode(userId),
-    sessionId: parseTime(sessionId),
-    lastEventTime: parseTime(lastEventTime),
-    optOut: Boolean(optOut),
-  };
-};
-
-export const parseTime = (num: string) => {
-  const integer = parseInt(num, 32);
-  if (isNaN(integer)) {
-    return undefined;
-  }
-  return integer;
-};
-
-export const decode = (value?: string): string | undefined => {
-  if (!atob || !escape || !value) {
-    return undefined;
-  }
-  try {
-    return decodeURIComponent(escape(atob(value)));
-  } catch {
-    return undefined;
-  }
-};

package/src/index.ts

@@ -1,24 +0,0 @@
-export {
-  add,
-  flush,
-  getDeviceId,
-  getSessionId,
-  getUserId,
-  groupIdentify,
-  identify,
-  init,
-  logEvent,
-  remove,
-  revenue,
-  setDeviceId,
-  setGroup,
-  setOptOut,
-  setSessionId,
-  setTransport,
-  setUserId,
-  track,
-} from './react-native-client';
-export { runQueuedFunctions } from './utils/snippet-helper';
-export { Revenue, Identify } from '@amplitude/analytics-core';
-import * as Types from '@amplitude/analytics-types';
-export { Types };

package/src/plugins/context.ts

@@ -1,106 +0,0 @@
-import { BeforePlugin, ReactNativeConfig, Event, PluginType } from '@amplitude/analytics-types';
-import UAParser from '@amplitude/ua-parser-js';
-import { UUID } from '@amplitude/analytics-core';
-import { getLanguage } from '../utils/language';
-import { VERSION } from '../version';
-import { NativeModules } from 'react-native';
-
-const BROWSER_PLATFORM = 'Web';
-const IP_ADDRESS = '$remote';
-
-type NativeContext = {
-  version: string;
-  platform: string;
-  language: string;
-  os_name: string;
-  os_version: string;
-  device_brand: string;
-  device_manufacturer: string;
-  device_model: string;
-  carrier: string;
-};
-
-export interface AmplitudeReactNative {
-  getApplicationContext(): Promise<NativeContext>;
-}
-
-export class Context implements BeforePlugin {
-  name = 'context';
-  type = PluginType.BEFORE as const;
-
-  // this.config is defined in setup() which will always be called first
-  // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-  // @ts-ignore
-  config: ReactNativeConfig;
-  eventId = 0;
-  uaResult: UAParser.IResult;
-  nativeModule: AmplitudeReactNative | undefined = NativeModules.AmplitudeReactNative as
-    | AmplitudeReactNative
-    | undefined;
-  library = `amplitude-react-native-ts/${VERSION}`;
-
-  constructor() {
-    let agent: string | undefined;
-    /* istanbul ignore else */
-    if (typeof navigator !== 'undefined') {
-      agent = navigator.userAgent;
-    }
-    this.uaResult = new UAParser(agent).getResult();
-  }
-
-  setup(config: ReactNativeConfig): Promise<undefined> {
-    this.config = config;
-    return Promise.resolve(undefined);
-  }
-
-  async execute(context: Event): Promise<Event> {
-    /**
-     * Manages user session triggered by new events
-     */
-    if (!this.isSessionValid()) {
-      // Creates new session
-      this.config.sessionId = Date.now();
-    } // else use previously creates session
-    // Updates last event time to extend time-based session
-    this.config.lastEventTime = Date.now();
-    const time = new Date().getTime();
-    const nativeContext = await this.nativeModule?.getApplicationContext();
-    const appVersion = nativeContext?.version || this.config.appVersion;
-    const platform = nativeContext?.platform || BROWSER_PLATFORM;
-    const osName = nativeContext?.os_name || this.uaResult.browser.name;
-    const osVersion = nativeContext?.os_version || this.uaResult.browser.version;
-    const deviceVendor = nativeContext?.device_manufacturer || this.uaResult.device.vendor;
-    const deviceModel = nativeContext?.device_model || this.uaResult.device.model || this.uaResult.os.name;
-    const language = nativeContext?.language || getLanguage();
-    const carrier = nativeContext?.carrier;
-
-    const event: Event = {
-      user_id: this.config.userId,
-      device_id: this.config.deviceId,
-      session_id: this.config.sessionId,
-      time,
-      ...(this.config.appVersion && { app_version: appVersion }),
-      ...(this.config.trackingOptions.platform && { platform: platform }),
-      ...(this.config.trackingOptions.osName && { os_name: osName }),
-      ...(this.config.trackingOptions.osVersion && { os_version: osVersion }),
-      ...(this.config.trackingOptions.deviceManufacturer && { device_manufacturer: deviceVendor }),
-      ...(this.config.trackingOptions.deviceModel && { device_model: deviceModel }),
-      ...(this.config.trackingOptions.language && { language: language }),
-      ...(this.config.trackingOptions.carrier && { carrier: carrier }),
-      ...(this.config.trackingOptions.ipAddress && { ip: IP_ADDRESS }),
-      insert_id: UUID(),
-      partner_id: this.config.partnerId,
-      plan: this.config.plan,
-      ...context,
-      event_id: this.eventId++,
-      library: this.library,
-    };
-    return event;
-  }
-
-  isSessionValid() {
-    const lastEventTime = this.config.lastEventTime || Date.now();
-    const timeSinceLastEvent = Date.now() - lastEventTime;
-    return timeSinceLastEvent < this.config.sessionTimeout;
-  }
-}