@snowplow/react-native-tracker 2.1.2 → 4.0.2-dev.0

package/src/subject.ts

@@ -1,302 +0,0 @@
-'use strict';
-
-import { RNSnowplowTracker } from './native';
-import { logMessages } from './constants';
-import { isScreenSize, isValidSubjectConf } from './configurations';
-import type { ScreenSize, SubjectConfiguration } from './types';
-
-/**
- * Sets the userId of the tracker subject
- *
- * @param namespace {string} - the tracker namespace
- * @param newUid {string | null} - the new userId
- * @returns - Promise
- */
-function setUserId(namespace: string, newUid: string | null): Promise<void> {
-  if (!(newUid === null || typeof newUid === 'string')) {
-    return Promise.reject(new Error(logMessages.setUserId));
-  }
-  return <Promise<void>>Promise.resolve(
-    RNSnowplowTracker.setUserId({
-      tracker: namespace,
-      userId: newUid,
-    })
-  );
-}
-
-/**
- * Sets the networkUserId of the tracker subject
- *
- * @param namespace {string} - the tracker namespace
- * @param newNuid {string | null} - the new networkUserId
- * @returns - Promise
- */
-function setNetworkUserId(
-  namespace: string,
-  newNuid: string | null
-): Promise<void> {
-  if (!(newNuid === null || typeof newNuid === 'string')) {
-    return Promise.reject(new Error(logMessages.setNetworkUserId));
-  }
-  return <Promise<void>>Promise.resolve(
-    RNSnowplowTracker.setNetworkUserId({
-      tracker: namespace,
-      networkUserId: newNuid,
-    })
-  );
-}
-
-/**
- * Sets the domainUserId of the tracker subject
- *
- * @param namespace {string} - the tracker namespace
- * @param newDuid {string | null} - the new domainUserId
- * @returns - Promise
- */
-function setDomainUserId(
-  namespace: string,
-  newDuid: string | null
-): Promise<void> {
-  if (!(newDuid === null || typeof newDuid === 'string')) {
-    return Promise.reject(new Error(logMessages.setDomainUserId));
-  }
-  return <Promise<void>>Promise.resolve(
-    RNSnowplowTracker.setDomainUserId({
-      tracker: namespace,
-      domainUserId: newDuid,
-    })
-  );
-}
-
-/**
- * Sets the ipAddress of the tracker subject
- *
- * @param namespace {string} - the tracker namespace
- * @param newIp {string | null} - the new ipAddress
- * @returns - Promise
- */
-function setIpAddress(namespace: string, newIp: string | null): Promise<void> {
-  if (!(newIp === null || typeof newIp === 'string')) {
-    return Promise.reject(new Error(logMessages.setIpAddress));
-  }
-  return <Promise<void>>Promise.resolve(
-    RNSnowplowTracker.setIpAddress({
-      tracker: namespace,
-      ipAddress: newIp,
-    })
-  );
-}
-
-/**
- * Sets the useragent of the tracker subject
- *
- * @param namespace {string} - the tracker namespace
- * @param newUagent {string | null} - the new useragent
- * @returns - Promise
- */
-function setUseragent(
-  namespace: string,
-  newUagent: string | null
-): Promise<void> {
-  if (!(newUagent === null || typeof newUagent === 'string')) {
-    return Promise.reject(new Error(logMessages.setUseragent));
-  }
-  return <Promise<void>>Promise.resolve(
-    RNSnowplowTracker.setUseragent({
-      tracker: namespace,
-      useragent: newUagent,
-    })
-  );
-}
-
-/**
- * Sets the timezone of the tracker subject
- *
- * @param namespace {string} - the tracker namespace
- * @param newTz {string | null} - the new timezone
- * @returns - Promise
- */
-function setTimezone(namespace: string, newTz: string | null): Promise<void> {
-  if (!(newTz === null || typeof newTz === 'string')) {
-    return Promise.reject(new Error(logMessages.setTimezone));
-  }
-  return <Promise<void>>Promise.resolve(
-    RNSnowplowTracker.setTimezone({
-      tracker: namespace,
-      timezone: newTz,
-    })
-  );
-}
-
-/**
- * Sets the language of the tracker subject
- *
- * @param namespace {string} - the tracker namespace
- * @param newLang {string | null} - the new language
- * @returns - Promise
- */
-function setLanguage(namespace: string, newLang: string | null): Promise<void> {
-  if (!(newLang === null || typeof newLang === 'string')) {
-    return Promise.reject(new Error(logMessages.setLanguage));
-  }
-  return <Promise<void>>Promise.resolve(
-    RNSnowplowTracker.setLanguage({
-      tracker: namespace,
-      language: newLang,
-    })
-  );
-}
-
-/**
- * Sets the screenResolution of the tracker subject
- *
- * @param namespace {string} - the tracker namespace
- * @param newRes {ScreenSize | null} - the new screenResolution
- * @returns - Promise
- */
-function setScreenResolution(
-  namespace: string,
-  newRes: ScreenSize | null
-): Promise<void> {
-  if (!(newRes === null || isScreenSize(newRes))) {
-    return Promise.reject(new Error(logMessages.setScreenResolution));
-  }
-  return <Promise<void>>Promise.resolve(
-    RNSnowplowTracker.setScreenResolution({
-      tracker: namespace,
-      screenResolution: newRes,
-    })
-  );
-}
-
-/**
- * Sets the screenViewport of the tracker subject
- *
- * @param namespace {string} - the tracker namespace
- * @param newView {ScreenSize | null} - the new screenViewport
- * @returns - Promise
- */
-function setScreenViewport(
-  namespace: string,
-  newView: ScreenSize | null
-): Promise<void> {
-  if (!(newView === null || isScreenSize(newView))) {
-    return Promise.reject(new Error(logMessages.setScreenViewport));
-  }
-  return <Promise<void>>Promise.resolve(
-    RNSnowplowTracker.setScreenViewport({
-      tracker: namespace,
-      screenViewport: newView,
-    })
-  );
-}
-
-/**
- * Sets the colorDepth of the tracker subject
- *
- * @param namespace {string} - the tracker namespace
- * @param newColorD {number | null} - the new colorDepth
- * @returns - Promise
- */
-function setColorDepth(
-  namespace: string,
-  newColorD: number | null
-): Promise<void> {
-  if (!(newColorD === null || typeof newColorD === 'number')) {
-    return Promise.reject(new Error(logMessages.setColorDepth));
-  }
-  return <Promise<void>>Promise.resolve(
-    RNSnowplowTracker.setColorDepth({
-      tracker: namespace,
-      colorDepth: newColorD,
-    })
-  );
-}
-
-const setterMap = {
-  userId: setUserId,
-  networkUserId: setNetworkUserId,
-  domainUserId: setDomainUserId,
-  ipAddress: setIpAddress,
-  useragent: setUseragent,
-  timezone: setTimezone,
-  language: setLanguage,
-  screenResolution: setScreenResolution,
-  screenViewport: setScreenViewport,
-  colorDepth: setColorDepth,
-} as Record<
-  keyof SubjectConfiguration,
-  <Type>(namespace: string, x: Type | null) => Promise<void>
->;
-
-/**
- * Sets the tracker subject
- *
- * @param namespace {string} - the tracker namespace
- * @param config {SubjectConfiguration} - the new subject data
- * @returns - Promise
- */
-function setSubjectData(
-  namespace: string,
-  config: SubjectConfiguration
-): Promise<void> {
-  if (!isValidSubjectConf(config)) {
-    return Promise.reject(
-      new Error(`${logMessages.setSubjectData} ${logMessages.subject}`)
-    );
-  }
-
-  const promises = Object.keys(config)
-    .map((k) => {
-      const fun = setterMap[k];
-      return fun ? fun(namespace, config[k]) : undefined;
-    })
-    .filter((f) => f !== undefined);
-
-  // to use Promise.all (Promise.allSettled not supported in all RN versions)
-  const safePromises = promises.map((p) =>
-    (p as Promise<void>)
-      .then(
-        (x) =>
-          Object.assign({
-            status: 'fulfilled',
-            value: x,
-          }) as PromiseFulfilledResult<void>
-      )
-      .catch(
-        (err) =>
-          Object.assign({
-            status: 'rejected',
-            reason: err.message as string,
-          }) as PromiseRejectedResult
-      )
-  );
-
-  return <Promise<void>>Promise.all(safePromises).then((outcomes) => {
-    const anyReasons = outcomes.filter(
-      (res) => res.status === 'rejected'
-    ) as PromiseRejectedResult[];
-    if (anyReasons.length > 0) {
-      const allReasons = anyReasons.reduce(
-        (acc, curr) => acc + ':' + curr.reason,
-        logMessages.setSubjectData
-      );
-      throw new Error(allReasons);
-    }
-    return true;
-  });
-}
-
-export {
-  setUserId,
-  setNetworkUserId,
-  setDomainUserId,
-  setIpAddress,
-  setUseragent,
-  setTimezone,
-  setLanguage,
-  setScreenResolution,
-  setScreenViewport,
-  setColorDepth,
-  setSubjectData,
-};

package/src/tracker.ts

@@ -1,377 +0,0 @@
-'use strict';
-
-import { RNSnowplowTracker } from './native';
-import { logMessages } from './constants';
-import {
-  validateContexts,
-  validateSelfDesc,
-  validateScreenView,
-  validateScrollChanged,
-  validateListItemView,
-  validateStructured,
-  validatePageView,
-  validateTiming,
-  validateConsentGranted,
-  validateConsentWithdrawn,
-  validateEcommerceTransaction,
-  validateDeepLinkReceived,
-  validateMessageNotification,
-} from './events';
-import type {
-  SelfDescribing,
-  EventContext,
-  ScreenViewProps,
-  StructuredProps,
-  PageViewProps,
-  TimingProps,
-  ConsentGrantedProps,
-  ConsentWithdrawnProps,
-  EcommerceTransactionProps,
-  DeepLinkReceivedProps,
-  MessageNotificationProps,
-  ScrollChangedProps,
-  ListItemViewProps,
-} from './types';
-
-/**
- * Tracks a self-describing event
- *
- * @param namespace {string} - the tracker namespace
- * @param argmap {Object} - the event data
- * @param contexts {Array}- the event contexts
- * @returns {Promise}
- */
-function trackSelfDescribingEvent(
-  namespace: string | null,
-  argmap: SelfDescribing,
-  contexts: EventContext[] = []
-): Promise<void> {
-  return <Promise<void>>validateSelfDesc(argmap)
-    .then(() => validateContexts(contexts))
-    .then(
-      () => <Promise<void>>RNSnowplowTracker.trackSelfDescribingEvent({
-          tracker: namespace,
-          eventData: argmap,
-          contexts: contexts,
-        })
-    )
-    .catch((error) => {
-      throw new Error(`${logMessages.trackSelfDesc} ${error.message}`);
-    });
-}
-
-/**
- * Tracks a screen-view event
- *
- * @param namespace {string} - the tracker namespace
- * @param argmap {Object} - the event data
- * @param contexts {Array}- the event contexts
- * @returns {Promise}
- */
-function trackScreenViewEvent(
-  namespace: string | null,
-  argmap: ScreenViewProps,
-  contexts: EventContext[] = []
-): Promise<void> {
-  return <Promise<void>>validateScreenView(argmap)
-    .then(() => validateContexts(contexts))
-    .then(
-      () => <Promise<void>>RNSnowplowTracker.trackScreenViewEvent({
-          tracker: namespace,
-          eventData: argmap,
-          contexts: contexts,
-        })
-    )
-    .catch((error) => {
-      throw new Error(`${logMessages.trackScreenView} ${error.message}`);
-    });
-}
-
-/**
- * Tracks a scroll-changed event
- *
- * @param namespace {string} - the tracker namespace
- * @param argmap {Object} - the event data
- * @param contexts {Array}- the event contexts
- * @returns {Promise}
- */
-function trackScrollChangedEvent(
-  namespace: string | null,
-  argmap: ScrollChangedProps,
-  contexts: EventContext[] = []
-): Promise<void> {
-  return <Promise<void>>validateScrollChanged(argmap)
-    .then(() => validateContexts(contexts))
-    .then(
-      () => <Promise<void>>RNSnowplowTracker.trackScrollChangedEvent({
-          tracker: namespace,
-          eventData: argmap,
-          contexts: contexts,
-        })
-    )
-    .catch((error) => {
-      throw new Error(`${logMessages.trackScrollChanged} ${error.message}`);
-    });
-}
-
-/**
- * Tracks a list item view event
- *
- * @param namespace {string} - the tracker namespace
- * @param argmap {Object} - the event data
- * @param contexts {Array}- the event contexts
- * @returns {Promise}
- */
-function trackListItemViewEvent(
-  namespace: string | null,
-  argmap: ListItemViewProps,
-  contexts: EventContext[] = []
-): Promise<void> {
-  return <Promise<void>>validateListItemView(argmap)
-    .then(() => validateContexts(contexts))
-    .then(
-      () => <Promise<void>>RNSnowplowTracker.trackListItemViewEvent({
-          tracker: namespace,
-          eventData: argmap,
-          contexts: contexts,
-        })
-    )
-    .catch((error) => {
-      throw new Error(`${logMessages.trackListItemView} ${error.message}`);
-    });
-}
-
-/**
- * Tracks a structured event
- *
- * @param namespace {string} - the tracker namespace
- * @param argmap {Object} - the event data
- * @param contexts {Array}- the event contexts
- * @returns {Promise}
- */
-function trackStructuredEvent(
-  namespace: string | null,
-  argmap: StructuredProps,
-  contexts: EventContext[] = []
-): Promise<void> {
-  return <Promise<void>>validateStructured(argmap)
-    .then(() => validateContexts(contexts))
-    .then(
-      () => <Promise<void>>RNSnowplowTracker.trackStructuredEvent({
-          tracker: namespace,
-          eventData: argmap,
-          contexts: contexts,
-        })
-    )
-    .catch((error) => {
-      throw new Error(`${logMessages.trackStructured} ${error.message}`);
-    });
-}
-
-/**
- * Tracks a page-view event
- *
- * @param namespace {string} - the tracker namespace
- * @param argmap {Object} - the event data
- * @param contexts {Array}- the event contexts
- * @returns {Promise}
- */
-function trackPageViewEvent(
-  namespace: string | null,
-  argmap: PageViewProps,
-  contexts: EventContext[] = []
-): Promise<void> {
-  return <Promise<void>>validatePageView(argmap)
-    .then(() => validateContexts(contexts))
-    .then(
-      () => <Promise<void>>RNSnowplowTracker.trackPageViewEvent({
-          tracker: namespace,
-          eventData: argmap,
-          contexts: contexts,
-        })
-    )
-    .catch((error) => {
-      throw new Error(`${logMessages.trackPageView} ${error.message}`);
-    });
-}
-
-/**
- * Tracks a timing event
- *
- * @param namespace {string} - the tracker namespace
- * @param argmap {Object} - the event data
- * @param contexts {Array}- the event contexts
- * @returns {Promise}
- */
-function trackTimingEvent(
-  namespace: string | null,
-  argmap: TimingProps,
-  contexts: EventContext[] = []
-): Promise<void> {
-  return <Promise<void>>validateTiming(argmap)
-    .then(() => validateContexts(contexts))
-    .then(
-      () => <Promise<void>>RNSnowplowTracker.trackTimingEvent({
-          tracker: namespace,
-          eventData: argmap,
-          contexts: contexts,
-        })
-    )
-    .catch((error) => {
-      throw new Error(`${logMessages.trackTiming} ${error.message}`);
-    });
-}
-
-/**
- * Tracks a consent-granted event
- *
- * @param namespace {string} - the tracker namespace
- * @param argmap {Object} - the event data
- * @param contexts {Array}- the event contexts
- * @returns {Promise}
- */
-function trackConsentGrantedEvent(
-  namespace: string | null,
-  argmap: ConsentGrantedProps,
-  contexts: EventContext[] = []
-): Promise<void> {
-  return <Promise<void>>validateConsentGranted(argmap)
-    .then(() => validateContexts(contexts))
-    .then(
-      () => <Promise<void>>RNSnowplowTracker.trackConsentGrantedEvent({
-          tracker: namespace,
-          eventData: argmap,
-          contexts: contexts,
-        })
-    )
-    .catch((error) => {
-      throw new Error(`${logMessages.trackConsentGranted} ${error.message}`);
-    });
-}
-
-/**
- * Tracks a consent-withdrawn event
- *
- * @param namespace {string} - the tracker namespace
- * @param argmap {Object} - the event data
- * @param contexts {Array}- the event contexts
- * @returns {Promise}
- */
-function trackConsentWithdrawnEvent(
-  namespace: string | null,
-  argmap: ConsentWithdrawnProps,
-  contexts: EventContext[] = []
-): Promise<void> {
-  return <Promise<void>>validateConsentWithdrawn(argmap)
-    .then(() => validateContexts(contexts))
-    .then(
-      () => <Promise<void>>RNSnowplowTracker.trackConsentWithdrawnEvent({
-          tracker: namespace,
-          eventData: argmap,
-          contexts: contexts,
-        })
-    )
-    .catch((error) => {
-      throw new Error(`${logMessages.trackConsentWithdrawn} ${error.message}`);
-    });
-}
-
-/**
- * Tracks an ecommerce-transaction event
- *
- * @param namespace {string} - the tracker namespace
- * @param argmap {Object} - the event data
- * @param contexts {Array}- the event contexts
- * @returns {Promise}
- */
-function trackEcommerceTransactionEvent(
-  namespace: string | null,
-  argmap: EcommerceTransactionProps,
-  contexts: EventContext[] = []
-): Promise<void> {
-  return <Promise<void>>validateEcommerceTransaction(argmap)
-    .then(() => validateContexts(contexts))
-    .then(
-      () => <Promise<void>>RNSnowplowTracker.trackEcommerceTransactionEvent({
-          tracker: namespace,
-          eventData: argmap,
-          contexts: contexts,
-        })
-    )
-    .catch((error) => {
-      throw new Error(
-        `${logMessages.trackEcommerceTransaction} ${error.message}`
-      );
-    });
-}
-
-/**
- * Tracks a deep link received event
- *
- * @param namespace {string} - the tracker namespace
- * @param argmap {Object} - the event data
- * @param contexts {Array}- the event contexts
- * @returns {Promise}
- */
-function trackDeepLinkReceivedEvent(
-  namespace: string | null,
-  argmap: DeepLinkReceivedProps,
-  contexts: EventContext[] = []
-): Promise<void> {
-  return <Promise<void>>validateDeepLinkReceived(argmap)
-    .then(() => validateContexts(contexts))
-    .then(
-      () => <Promise<void>>RNSnowplowTracker.trackDeepLinkReceivedEvent({
-          tracker: namespace,
-          eventData: argmap,
-          contexts: contexts,
-        })
-    )
-    .catch((error) => {
-      throw new Error(`${logMessages.trackDeepLinkReceived} ${error.message}`);
-    });
-}
-
-/**
- * Tracks a message notification event
- *
- * @param namespace {string} - the tracker namespace
- * @param argmap {Object} - the event data
- * @param contexts {Array}- the event contexts
- * @returns {Promise}
- */
-function trackMessageNotificationEvent(
-  namespace: string | null,
-  argmap: MessageNotificationProps,
-  contexts: EventContext[] = []
-): Promise<void> {
-  return <Promise<void>>validateMessageNotification(argmap)
-    .then(() => validateContexts(contexts))
-    .then(
-      () => <Promise<void>>RNSnowplowTracker.trackMessageNotificationEvent({
-          tracker: namespace,
-          eventData: argmap,
-          contexts: contexts,
-        })
-    )
-    .catch((error) => {
-      throw new Error(
-        `${logMessages.trackMessageNotification} ${error.message}`
-      );
-    });
-}
-
-export {
-  trackSelfDescribingEvent,
-  trackScreenViewEvent,
-  trackScrollChangedEvent,
-  trackListItemViewEvent,
-  trackStructuredEvent,
-  trackPageViewEvent,
-  trackTimingEvent,
-  trackConsentGrantedEvent,
-  trackConsentWithdrawnEvent,
-  trackEcommerceTransactionEvent,
-  trackDeepLinkReceivedEvent,
-  trackMessageNotificationEvent,
-};