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

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Amplitude Analytics
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/lib/commonjs/index.js

@@ -123,9 +123,9 @@ var _reactNativeClient = require("./react-native-client");
 
 var _analyticsCore = require("@amplitude/analytics-core");
 
-var _Types = _interopRequireWildcard(require("@amplitude/analytics-types"));
+var Types = _interopRequireWildcard(require("@amplitude/analytics-types"));
 
-exports.Types = _Types;
+exports.Types = Types;
 
 function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
 

package/lib/commonjs/index.js.map

@@ -1 +1 @@
-{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["export {\n  add,\n  flush,\n  getDeviceId,\n  getSessionId,\n  getUserId,\n  groupIdentify,\n  identify,\n  init,\n  logEvent,\n  remove,\n  revenue,\n  setDeviceId,\n  setGroup,\n  setOptOut,\n  setSessionId,\n  setUserId,\n  track,\n} from './react-native-client';\nexport { Revenue, Identify } from '@amplitude/analytics-core';\nexport * as Types from '@amplitude/analytics-types';\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;AAmBA"}
+{"version":3,"names":[],"sources":["index.ts"],"sourcesContent":["export {\n  add,\n  flush,\n  getDeviceId,\n  getSessionId,\n  getUserId,\n  groupIdentify,\n  identify,\n  init,\n  logEvent,\n  remove,\n  revenue,\n  setDeviceId,\n  setGroup,\n  setOptOut,\n  setSessionId,\n  setUserId,\n  track,\n} from './react-native-client';\nexport { Revenue, Identify } from '@amplitude/analytics-core';\n// Hack - react-native apps have trouble with:\n// export * as Types from '@amplitude/analytics-types\nimport * as Types from '@amplitude/analytics-types';\nexport { Types };\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;;AAmBA;;AAGA"}

package/lib/commonjs/plugins/identity.js

@@ -24,7 +24,7 @@ class IdentityEventSender {
     const userProperties = context.user_properties;
 
     if (userProperties) {
-      this.identityStore.editIdentity().setUserProperties(userProperties).commit();
+      this.identityStore.editIdentity().updateUserProperties(userProperties).commit();
     }
 
     return context;

package/lib/commonjs/plugins/identity.js.map

@@ -1 +1 @@
-{"version":3,"names":["IdentityEventSender","PluginType","BEFORE","getAnalyticsConnector","identityStore","execute","context","userProperties","user_properties","editIdentity","setUserProperties","commit","setup","_","Promise","resolve","undefined"],"sources":["identity.ts"],"sourcesContent":["import { BeforePlugin, PluginType, Event, Config } from '@amplitude/analytics-types';\nimport { getAnalyticsConnector } from '../utils/analytics-connector';\n\nexport class IdentityEventSender implements BeforePlugin {\n  name = 'identity';\n  type = PluginType.BEFORE as const;\n\n  identityStore = getAnalyticsConnector().identityStore;\n\n  async execute(context: Event): Promise<Event> {\n    const userProperties = context.user_properties as Record<string, any>;\n    if (userProperties) {\n      this.identityStore.editIdentity().setUserProperties(userProperties).commit();\n    }\n    return context;\n  }\n\n  setup(_: Config): Promise<undefined> {\n    return Promise.resolve(undefined);\n  }\n}\n"],"mappings":";;;;;;;AAAA;;AACA;;;;AAEO,MAAMA,mBAAN,CAAkD;EAAA;IAAA,8BAChD,UADgD;;IAAA,8BAEhDC,0BAAA,CAAWC,MAFqC;;IAAA,uCAIvC,IAAAC,yCAAA,IAAwBC,aAJe;EAAA;;EAM1C,MAAPC,OAAO,CAACC,OAAD,EAAiC;IAC5C,MAAMC,cAAc,GAAGD,OAAO,CAACE,eAA/B;;IACA,IAAID,cAAJ,EAAoB;MAClB,KAAKH,aAAL,CAAmBK,YAAnB,GAAkCC,iBAAlC,CAAoDH,cAApD,EAAoEI,MAApE;IACD;;IACD,OAAOL,OAAP;EACD;;EAEDM,KAAK,CAACC,CAAD,EAAgC;IACnC,OAAOC,OAAO,CAACC,OAAR,CAAgBC,SAAhB,CAAP;EACD;;AAhBsD"}
+{"version":3,"names":["IdentityEventSender","PluginType","BEFORE","getAnalyticsConnector","identityStore","execute","context","userProperties","user_properties","editIdentity","updateUserProperties","commit","setup","_","Promise","resolve","undefined"],"sources":["identity.ts"],"sourcesContent":["import { BeforePlugin, PluginType, Event, Config } from '@amplitude/analytics-types';\nimport { getAnalyticsConnector } from '../utils/analytics-connector';\n\nexport class IdentityEventSender implements BeforePlugin {\n  name = 'identity';\n  type = PluginType.BEFORE as const;\n\n  identityStore = getAnalyticsConnector().identityStore;\n\n  async execute(context: Event): Promise<Event> {\n    const userProperties = context.user_properties as Record<string, any>;\n    if (userProperties) {\n      this.identityStore.editIdentity().updateUserProperties(userProperties).commit();\n    }\n    return context;\n  }\n\n  setup(_: Config): Promise<undefined> {\n    return Promise.resolve(undefined);\n  }\n}\n"],"mappings":";;;;;;;AAAA;;AACA;;;;AAEO,MAAMA,mBAAN,CAAkD;EAAA;IAAA,8BAChD,UADgD;;IAAA,8BAEhDC,0BAAA,CAAWC,MAFqC;;IAAA,uCAIvC,IAAAC,yCAAA,IAAwBC,aAJe;EAAA;;EAM1C,MAAPC,OAAO,CAACC,OAAD,EAAiC;IAC5C,MAAMC,cAAc,GAAGD,OAAO,CAACE,eAA/B;;IACA,IAAID,cAAJ,EAAoB;MAClB,KAAKH,aAAL,CAAmBK,YAAnB,GAAkCC,oBAAlC,CAAuDH,cAAvD,EAAuEI,MAAvE;IACD;;IACD,OAAOL,OAAP;EACD;;EAEDM,KAAK,CAACC,CAAD,EAAgC;IACnC,OAAOC,OAAO,CAACC,OAAR,CAAgBC,SAAhB,CAAP;EACD;;AAhBsD"}

package/lib/commonjs/version.js

@@ -4,6 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.VERSION = void 0;
-const VERSION = '0.0.1-dev.7';
+const VERSION = '0.1.0';
 exports.VERSION = VERSION;
 //# sourceMappingURL=version.js.map

package/lib/commonjs/version.js.map

@@ -1 +1 @@
-{"version":3,"names":["VERSION"],"sources":["version.ts"],"sourcesContent":["export const VERSION = '0.0.1-dev.7';\n"],"mappings":";;;;;;AAAO,MAAMA,OAAO,GAAG,aAAhB"}
+{"version":3,"names":["VERSION"],"sources":["version.ts"],"sourcesContent":["export const VERSION = '0.1.0';\n"],"mappings":";;;;;;AAAO,MAAMA,OAAO,GAAG,OAAhB"}

package/lib/module/index.js

@@ -1,5 +1,7 @@
 export { add, flush, getDeviceId, getSessionId, getUserId, groupIdentify, identify, init, logEvent, remove, revenue, setDeviceId, setGroup, setOptOut, setSessionId, setUserId, track } from './react-native-client';
-export { Revenue, Identify } from '@amplitude/analytics-core';
-import * as _Types from '@amplitude/analytics-types';
-export { _Types as Types };
+export { Revenue, Identify } from '@amplitude/analytics-core'; // Hack - react-native apps have trouble with:
+// export * as Types from '@amplitude/analytics-types
+
+import * as Types from '@amplitude/analytics-types';
+export { Types };
 //# sourceMappingURL=index.js.map

package/lib/module/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["add","flush","getDeviceId","getSessionId","getUserId","groupIdentify","identify","init","logEvent","remove","revenue","setDeviceId","setGroup","setOptOut","setSessionId","setUserId","track","Revenue","Identify","Types"],"sources":["index.ts"],"sourcesContent":["export {\n  add,\n  flush,\n  getDeviceId,\n  getSessionId,\n  getUserId,\n  groupIdentify,\n  identify,\n  init,\n  logEvent,\n  remove,\n  revenue,\n  setDeviceId,\n  setGroup,\n  setOptOut,\n  setSessionId,\n  setUserId,\n  track,\n} from './react-native-client';\nexport { Revenue, Identify } from '@amplitude/analytics-core';\nexport * as Types from '@amplitude/analytics-types';\n"],"mappings":"AAAA,SACEA,GADF,EAEEC,KAFF,EAGEC,WAHF,EAIEC,YAJF,EAKEC,SALF,EAMEC,aANF,EAOEC,QAPF,EAQEC,IARF,EASEC,QATF,EAUEC,MAVF,EAWEC,OAXF,EAYEC,WAZF,EAaEC,QAbF,EAcEC,SAdF,EAeEC,YAfF,EAgBEC,SAhBF,EAiBEC,KAjBF,QAkBO,uBAlBP;AAmBA,SAASC,OAAT,EAAkBC,QAAlB,QAAkC,2BAAlC;wBACuB,4B;mBAAXC,K"}
+{"version":3,"names":["add","flush","getDeviceId","getSessionId","getUserId","groupIdentify","identify","init","logEvent","remove","revenue","setDeviceId","setGroup","setOptOut","setSessionId","setUserId","track","Revenue","Identify","Types"],"sources":["index.ts"],"sourcesContent":["export {\n  add,\n  flush,\n  getDeviceId,\n  getSessionId,\n  getUserId,\n  groupIdentify,\n  identify,\n  init,\n  logEvent,\n  remove,\n  revenue,\n  setDeviceId,\n  setGroup,\n  setOptOut,\n  setSessionId,\n  setUserId,\n  track,\n} from './react-native-client';\nexport { Revenue, Identify } from '@amplitude/analytics-core';\n// Hack - react-native apps have trouble with:\n// export * as Types from '@amplitude/analytics-types\nimport * as Types from '@amplitude/analytics-types';\nexport { Types };\n"],"mappings":"AAAA,SACEA,GADF,EAEEC,KAFF,EAGEC,WAHF,EAIEC,YAJF,EAKEC,SALF,EAMEC,aANF,EAOEC,QAPF,EAQEC,IARF,EASEC,QATF,EAUEC,MAVF,EAWEC,OAXF,EAYEC,WAZF,EAaEC,QAbF,EAcEC,SAdF,EAeEC,YAfF,EAgBEC,SAhBF,EAiBEC,KAjBF,QAkBO,uBAlBP;AAmBA,SAASC,OAAT,EAAkBC,QAAlB,QAAkC,2BAAlC,C,CACA;AACA;;AACA,OAAO,KAAKC,KAAZ,MAAuB,4BAAvB;AACA,SAASA,KAAT"}

package/lib/module/plugins/identity.js

@@ -15,7 +15,7 @@ export class IdentityEventSender {
     const userProperties = context.user_properties;
 
     if (userProperties) {
-      this.identityStore.editIdentity().setUserProperties(userProperties).commit();
+      this.identityStore.editIdentity().updateUserProperties(userProperties).commit();
     }
 
     return context;

package/lib/module/plugins/identity.js.map

@@ -1 +1 @@
-{"version":3,"names":["PluginType","getAnalyticsConnector","IdentityEventSender","BEFORE","identityStore","execute","context","userProperties","user_properties","editIdentity","setUserProperties","commit","setup","_","Promise","resolve","undefined"],"sources":["identity.ts"],"sourcesContent":["import { BeforePlugin, PluginType, Event, Config } from '@amplitude/analytics-types';\nimport { getAnalyticsConnector } from '../utils/analytics-connector';\n\nexport class IdentityEventSender implements BeforePlugin {\n  name = 'identity';\n  type = PluginType.BEFORE as const;\n\n  identityStore = getAnalyticsConnector().identityStore;\n\n  async execute(context: Event): Promise<Event> {\n    const userProperties = context.user_properties as Record<string, any>;\n    if (userProperties) {\n      this.identityStore.editIdentity().setUserProperties(userProperties).commit();\n    }\n    return context;\n  }\n\n  setup(_: Config): Promise<undefined> {\n    return Promise.resolve(undefined);\n  }\n}\n"],"mappings":";;AAAA,SAAuBA,UAAvB,QAAwD,4BAAxD;AACA,SAASC,qBAAT,QAAsC,8BAAtC;AAEA,OAAO,MAAMC,mBAAN,CAAkD;EAAA;IAAA,8BAChD,UADgD;;IAAA,8BAEhDF,UAAU,CAACG,MAFqC;;IAAA,uCAIvCF,qBAAqB,GAAGG,aAJe;EAAA;;EAM1C,MAAPC,OAAO,CAACC,OAAD,EAAiC;IAC5C,MAAMC,cAAc,GAAGD,OAAO,CAACE,eAA/B;;IACA,IAAID,cAAJ,EAAoB;MAClB,KAAKH,aAAL,CAAmBK,YAAnB,GAAkCC,iBAAlC,CAAoDH,cAApD,EAAoEI,MAApE;IACD;;IACD,OAAOL,OAAP;EACD;;EAEDM,KAAK,CAACC,CAAD,EAAgC;IACnC,OAAOC,OAAO,CAACC,OAAR,CAAgBC,SAAhB,CAAP;EACD;;AAhBsD"}
+{"version":3,"names":["PluginType","getAnalyticsConnector","IdentityEventSender","BEFORE","identityStore","execute","context","userProperties","user_properties","editIdentity","updateUserProperties","commit","setup","_","Promise","resolve","undefined"],"sources":["identity.ts"],"sourcesContent":["import { BeforePlugin, PluginType, Event, Config } from '@amplitude/analytics-types';\nimport { getAnalyticsConnector } from '../utils/analytics-connector';\n\nexport class IdentityEventSender implements BeforePlugin {\n  name = 'identity';\n  type = PluginType.BEFORE as const;\n\n  identityStore = getAnalyticsConnector().identityStore;\n\n  async execute(context: Event): Promise<Event> {\n    const userProperties = context.user_properties as Record<string, any>;\n    if (userProperties) {\n      this.identityStore.editIdentity().updateUserProperties(userProperties).commit();\n    }\n    return context;\n  }\n\n  setup(_: Config): Promise<undefined> {\n    return Promise.resolve(undefined);\n  }\n}\n"],"mappings":";;AAAA,SAAuBA,UAAvB,QAAwD,4BAAxD;AACA,SAASC,qBAAT,QAAsC,8BAAtC;AAEA,OAAO,MAAMC,mBAAN,CAAkD;EAAA;IAAA,8BAChD,UADgD;;IAAA,8BAEhDF,UAAU,CAACG,MAFqC;;IAAA,uCAIvCF,qBAAqB,GAAGG,aAJe;EAAA;;EAM1C,MAAPC,OAAO,CAACC,OAAD,EAAiC;IAC5C,MAAMC,cAAc,GAAGD,OAAO,CAACE,eAA/B;;IACA,IAAID,cAAJ,EAAoB;MAClB,KAAKH,aAAL,CAAmBK,YAAnB,GAAkCC,oBAAlC,CAAuDH,cAAvD,EAAuEI,MAAvE;IACD;;IACD,OAAOL,OAAP;EACD;;EAEDM,KAAK,CAACC,CAAD,EAAgC;IACnC,OAAOC,OAAO,CAACC,OAAR,CAAgBC,SAAhB,CAAP;EACD;;AAhBsD"}

package/lib/module/version.js

@@ -1,2 +1,2 @@
-export const VERSION = '0.0.1-dev.7';
+export const VERSION = '0.1.0';
 //# sourceMappingURL=version.js.map

package/lib/module/version.js.map

@@ -1 +1 @@
-{"version":3,"names":["VERSION"],"sources":["version.ts"],"sourcesContent":["export const VERSION = '0.0.1-dev.7';\n"],"mappings":"AAAA,OAAO,MAAMA,OAAO,GAAG,aAAhB"}
+{"version":3,"names":["VERSION"],"sources":["version.ts"],"sourcesContent":["export const VERSION = '0.1.0';\n"],"mappings":"AAAA,OAAO,MAAMA,OAAO,GAAG,OAAhB"}

package/lib/typescript/index.d.ts

@@ -1,4 +1,5 @@
 export { add, flush, getDeviceId, getSessionId, getUserId, groupIdentify, identify, init, logEvent, remove, revenue, setDeviceId, setGroup, setOptOut, setSessionId, setUserId, track, } from './react-native-client';
 export { Revenue, Identify } from '@amplitude/analytics-core';
-export * as Types from '@amplitude/analytics-types';
+import * as Types from '@amplitude/analytics-types';
+export { Types };
 //# sourceMappingURL=index.d.ts.map

package/lib/typescript/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,GAAG,EACH,KAAK,EACL,WAAW,EACX,YAAY,EACZ,SAAS,EACT,aAAa,EACb,QAAQ,EACR,IAAI,EACJ,QAAQ,EACR,MAAM,EACN,OAAO,EACP,WAAW,EACX,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,SAAS,EACT,KAAK,GACN,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAC9D,OAAO,KAAK,KAAK,MAAM,4BAA4B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,GAAG,EACH,KAAK,EACL,WAAW,EACX,YAAY,EACZ,SAAS,EACT,aAAa,EACb,QAAQ,EACR,IAAI,EACJ,QAAQ,EACR,MAAM,EACN,OAAO,EACP,WAAW,EACX,QAAQ,EACR,SAAS,EACT,YAAY,EACZ,SAAS,EACT,KAAK,GACN,MAAM,uBAAuB,CAAC;AAC/B,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,MAAM,2BAA2B,CAAC;AAG9D,OAAO,KAAK,KAAK,MAAM,4BAA4B,CAAC;AACpD,OAAO,EAAE,KAAK,EAAE,CAAC"}

package/lib/typescript/version.d.ts

@@ -1,2 +1,2 @@
-export declare const VERSION = "0.0.1-dev.7";
+export declare const VERSION = "0.1.0";
 //# sourceMappingURL=version.d.ts.map

package/lib/typescript/version.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,gBAAgB,CAAC"}
+{"version":3,"file":"version.d.ts","sourceRoot":"","sources":["../../src/version.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,OAAO,UAAU,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@amplitude/analytics-react-native",
-  "version": "0.0.1-dev.7",
+  "version": "0.1.0",
   "description": "Official React Native SDK",
   "keywords": [
     "analytics",
@@ -44,11 +44,11 @@
   },
   "source": "src/index",
   "files": [
+    "src",
     "lib",
     "android",
     "ios",
     "amplitude-react-native.podspec",
-    "!lib/typescript/example",
     "!android/build",
     "!ios/build",
     "!**/test"
@@ -58,11 +58,11 @@
   },
   "dependencies": {
     "@amplitude/analytics-connector": "1.4.4",
-    "@amplitude/analytics-core": "^0.6.1",
-    "@amplitude/analytics-types": "^0.5.1",
+    "@amplitude/analytics-core": "^0.6.3",
+    "@amplitude/analytics-types": "^0.6.0",
     "@amplitude/ua-parser-js": "^0.7.31",
-    "tslib": "^2.3.1",
-    "@react-native-async-storage/async-storage": "^1.17.7"
+    "@react-native-async-storage/async-storage": "^1.17.7",
+    "tslib": "^2.3.1"
   },
   "devDependencies": {
     "@types/react": "^16.9.19",
@@ -88,5 +88,6 @@
         }
       ]
     ]
-  }
+  },
+  "gitHead": "ccece5d22caa0ae00b64cece3165ebc0a81dfc93"
 }

package/src/attribution/campaign-parser.ts

@@ -0,0 +1,78 @@
+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

@@ -0,0 +1,112 @@
+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 = 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

@@ -0,0 +1,32 @@
+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

@@ -0,0 +1,227 @@
+import {
+  Event,
+  ReactNativeOptions,
+  ReactNativeConfig as IReactNativeConfig,
+  Storage,
+  TrackingOptions,
+  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 { 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 ?? new FetchTransport(),
+  });
+};
+
+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 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 '';
+};