@jmartins-tillster/analytics-react-native 2.21.3

package/packages/core/src/types.ts

@@ -0,0 +1,392 @@
+import type { Persistor } from '@segment/sovran-react-native';
+import type { Rule } from '@segment/tsub/dist/store';
+import type { SegmentError } from './errors';
+import type { FlushPolicy } from './flushPolicies';
+import type { NativeModule } from 'react-native';
+
+export type JsonValue =
+  | boolean
+  | number
+  | string
+  | null
+  | JsonList
+  | JsonMap
+  | undefined;
+export interface JsonMap {
+  [key: string]: JsonValue;
+  [index: number]: JsonValue;
+}
+export type JsonList = Array<JsonValue>;
+
+export type SegmentEvent =
+  | TrackEventType
+  | ScreenEventType
+  | IdentifyEventType
+  | GroupEventType
+  | AliasEventType;
+
+interface BaseEventType {
+  anonymousId?: string;
+  messageId?: string;
+  userId?: string;
+  timestamp?: string;
+
+  context?: PartialContext;
+  integrations?: SegmentAPIIntegrations;
+  _metadata?: DestinationMetadata;
+  enrichment?: EnrichmentClosure;
+}
+
+export interface TrackEventType extends BaseEventType {
+  type: EventType.TrackEvent;
+  event: string;
+  properties?: JsonMap;
+}
+
+export interface ScreenEventType extends BaseEventType {
+  type: EventType.ScreenEvent;
+  name: string;
+  properties: JsonMap;
+}
+
+export interface IdentifyEventType extends BaseEventType {
+  type: EventType.IdentifyEvent;
+  traits?: UserTraits;
+}
+
+export interface GroupEventType extends BaseEventType {
+  type: EventType.GroupEvent;
+  groupId: string;
+  traits?: GroupTraits;
+}
+
+export interface AliasEventType extends BaseEventType {
+  type: EventType.AliasEvent;
+  userId?: string;
+  previousId: string;
+}
+
+export type UserTraits = JsonMap & {
+  address?: {
+    city?: string;
+    country?: string;
+    postalCode?: string;
+    state?: string;
+    street?: string;
+  };
+  age?: number;
+  avatar?: string;
+  birthday?: string;
+  company?: {
+    name?: string;
+    id?: string | number;
+    industry?: string;
+    employee_count?: number;
+    plan?: string;
+  };
+  createdAt?: string;
+  description?: string;
+  email?: string;
+  firstName?: string;
+  gender?: string;
+  id?: string;
+  lastName?: string;
+  name?: string;
+  phone?: string;
+  title?: string;
+  username?: string;
+  website?: string;
+};
+
+export type GroupTraits = JsonMap & {
+  address?: {
+    city?: string;
+    country?: string;
+    postalCode?: string;
+    state?: string;
+    street?: string;
+  };
+  avatar?: string;
+  createdAt?: string;
+  description?: string;
+  email?: string;
+  employees?: string;
+  id?: string;
+  industry?: string;
+  name?: string;
+  phone?: string;
+  website?: string;
+  plan?: string;
+};
+
+export interface LoggerType {
+  info(message?: unknown, ...optionalParams: unknown[]): void;
+  warn(message?: unknown, ...optionalParams: unknown[]): void;
+  error(message?: unknown, ...optionalParams: unknown[]): void;
+}
+
+export interface DeactivableLoggerType extends LoggerType {
+  enable(): void;
+  disable(): void;
+}
+
+export type Config = {
+  writeKey: string;
+  debug?: boolean;
+  logger?: DeactivableLoggerType;
+  // Legacy, for compat only
+  flushAt?: number;
+  flushInterval?: number;
+  // New flush policies
+  flushPolicies?: FlushPolicy[];
+  trackAppLifecycleEvents?: boolean;
+  maxBatchSize?: number;
+  trackDeepLinks?: boolean;
+  defaultSettings?: SegmentAPISettings;
+  autoAddSegmentDestination?: boolean;
+  collectDeviceId?: boolean;
+  storePersistor?: Persistor;
+  storePersistorSaveDelay?: number;
+  proxy?: string;
+  cdnProxy?: string;
+  useSegmentEndpoints?: boolean; // Use if you want to use Segment endpoints
+  errorHandler?: (error: SegmentError) => void;
+};
+
+export type ClientMethods = {
+  screen: (
+    name: string,
+    properties?: JsonMap,
+    enrichment?: EnrichmentClosure
+  ) => Promise<void>;
+  track: (
+    event: string,
+    properties?: JsonMap,
+    enrichment?: EnrichmentClosure
+  ) => Promise<void>;
+  identify: (
+    userId?: string,
+    userTraits?: UserTraits,
+    enrichment?: EnrichmentClosure
+  ) => Promise<void>;
+  flush: () => Promise<void>;
+  group: (
+    groupId: string,
+    groupTraits?: GroupTraits,
+    enrichment?: EnrichmentClosure
+  ) => Promise<void>;
+  alias: (newUserId: string, enrichment?: EnrichmentClosure) => Promise<void>;
+  reset: (resetAnonymousId?: boolean) => Promise<void>;
+};
+
+type ContextApp = {
+  build: string;
+  name: string;
+  namespace: string;
+  version: string;
+};
+
+export type ContextDevice = {
+  id?: string;
+  manufacturer: string;
+  model: string;
+  name: string;
+  type: string;
+
+  adTrackingEnabled?: boolean; // ios only
+  advertisingId?: string; // ios only
+  trackingStatus?: string;
+  token?: string;
+};
+
+type ContextLibrary = {
+  name: string;
+  version: string;
+};
+
+type ContextNetwork = {
+  cellular: boolean;
+  wifi: boolean;
+};
+
+type ContextOS = {
+  name: string;
+  version: string;
+};
+
+type ContextScreen = {
+  height: number;
+  width: number;
+  density?: number; // android only
+};
+
+export type Context = {
+  app: ContextApp;
+  device: ContextDevice;
+  library: ContextLibrary;
+  locale: string;
+  network: ContextNetwork;
+  os: ContextOS;
+  screen: ContextScreen;
+  timezone: string;
+  traits: UserTraits;
+  instanceId: string;
+  consent?: {
+    categoryPreferences: Record<string, boolean>;
+  };
+  __eventOrigin?: {
+    type: string;
+    version?: string;
+  };
+};
+
+/**
+ * Makes all the properties in an object optional
+ */
+export type DeepPartial<T> = {
+  [Property in keyof T]?: Property extends object
+    ? DeepPartial<T[Property]>
+    : Partial<T[Property]>;
+};
+
+export type PartialContext = DeepPartial<Context>;
+
+export type NativeContextInfo = {
+  appName: string;
+  appVersion: string;
+  buildNumber: string;
+  bundleId: string;
+  locale: string;
+  networkType: string;
+  osName: string;
+  osVersion: string;
+  screenHeight: number;
+  screenWidth: number;
+  screenDensity?: number; // android only
+  timezone: string;
+  manufacturer: string;
+  model: string;
+  deviceName: string;
+  deviceId?: string;
+  deviceType: string;
+  adTrackingEnabled?: boolean; // ios only
+  advertisingId?: string; // ios only
+};
+
+export type SegmentAPIIntegration<T = object> = {
+  apiKey: string;
+  apiHost: string;
+  consentSettings?: {
+    categories: string[];
+  };
+} & T;
+
+type SegmentAmplitudeIntegration = {
+  session_id: number;
+};
+
+export type SegmentAdjustSettings = {
+  appToken: string;
+  setEnvironmentProduction?: boolean;
+  trackAttributionData?: boolean;
+  customEvents?: { [key: string]: string };
+};
+
+export type SegmentBrazeSettings = {
+  logPurchaseWhenRevenuePresent: boolean;
+};
+
+export type IntegrationSettings =
+  // Strongly typed known integration settings
+  | SegmentAPIIntegration<SegmentAmplitudeIntegration>
+  | SegmentAPIIntegration<SegmentAdjustSettings>
+  // Support any kind of configuration in the future
+  | Record<string, unknown>
+  // enable/disable the integration at cloud level
+  | boolean;
+
+export type SegmentAPIIntegrations = {
+  [key: string]: IntegrationSettings;
+};
+
+export type SegmentAPIConsentSettings = {
+  allCategories: string[];
+  hasUnmappedDestinations: boolean;
+};
+
+export type RoutingRule = Rule;
+
+export interface MetricsOptions {
+  host?: string;
+  sampleRate?: number;
+  flushTimer?: number;
+  maxQueueSize?: number;
+}
+
+export interface DestinationFilters {
+  [key: string]: RoutingRule;
+}
+
+export interface EdgeFunctionSettings {
+  downloadURL: string;
+  version: string;
+}
+
+export type SegmentAPISettings = {
+  integrations: SegmentAPIIntegrations;
+  edgeFunction?: EdgeFunctionSettings;
+  middlewareSettings?: {
+    routingRules: RoutingRule[];
+  };
+  metrics?: MetricsOptions;
+  consentSettings?: SegmentAPIConsentSettings;
+};
+
+export type DestinationMetadata = {
+  bundled: string[];
+  unbundled: string[];
+  bundledIds: string[];
+};
+
+export enum PluginType {
+  // Executed before event processing begins.
+  'before' = 'before',
+  // Executed as the first level of event processing.
+  'enrichment' = 'enrichment',
+  // Executed as events begin to pass off to destinations.
+  'destination' = 'destination',
+  // Executed after all event processing is completed.  This can be used to perform cleanup operations, etc.
+  'after' = 'after',
+  // Executed only when called manually, such as Logging.
+  'utility' = 'utility',
+}
+
+export enum UpdateType {
+  'initial' = 'initial',
+  'refresh' = 'refresh',
+}
+
+export enum EventType {
+  'TrackEvent' = 'track',
+  'IdentifyEvent' = 'identify',
+  'ScreenEvent' = 'screen',
+  'GroupEvent' = 'group',
+  'AliasEvent' = 'alias',
+}
+
+export type UserInfoState = {
+  anonymousId: string;
+  userId?: string;
+  traits?: UserTraits | GroupTraits;
+};
+
+// Native Module types
+export interface GetContextConfig {
+  collectDeviceId: boolean;
+}
+
+export type AnalyticsReactNativeModule = NativeModule & {
+  getContextInfo: (config: GetContextConfig) => Promise<NativeContextInfo>;
+};
+
+export type EnrichmentClosure = (event: SegmentEvent) => SegmentEvent;

package/packages/core/src/util.ts

@@ -0,0 +1,288 @@
+import { NativeModule, NativeModules, Platform } from 'react-native';
+import type { EventPlugin } from './plugin';
+import type { Timeline } from './timeline';
+
+const sizeOf = (obj: unknown): number => {
+  const size = encodeURI(JSON.stringify(obj)).split(/%..|./).length - 1;
+  return size / 1024;
+};
+
+export const warnMissingNativeModule = () => {
+  const MISSING_NATIVE_MODULE_WARNING =
+    "The package 'analytics-react-native' can't access a custom native module. Make sure: \n\n" +
+    Platform.select({ ios: "- You have run 'pod install'\n", default: '' }) +
+    '- You rebuilt the app after installing the package\n' +
+    '- You are not using Expo managed workflow\n';
+  console.warn(MISSING_NATIVE_MODULE_WARNING);
+};
+
+export const getNativeModule = (moduleName: string) => {
+  const module = (NativeModules[moduleName] as NativeModule) ?? undefined;
+  if (module === undefined) {
+    warnMissingNativeModule();
+  }
+  return module;
+};
+
+export const chunk = <T>(array: T[], count: number, maxKB?: number): T[][] => {
+  if (!array.length || !count) {
+    return [];
+  }
+
+  let currentChunk = 0;
+  let rollingKBSize = 0;
+  const result: T[][] = array.reduce(
+    (chunks: T[][], item: T, index: number) => {
+      if (maxKB !== undefined) {
+        rollingKBSize += sizeOf(item);
+        // If we overflow chunk until the previous index, else keep going
+        if (rollingKBSize >= maxKB) {
+          chunks[++currentChunk] = [item];
+          return chunks;
+        }
+      }
+
+      if (index !== 0 && index % count === 0) {
+        chunks[++currentChunk] = [item];
+      } else {
+        if (chunks[currentChunk] === undefined) {
+          chunks[currentChunk] = [];
+        }
+        chunks[currentChunk].push(item);
+      }
+
+      return chunks;
+    },
+    []
+  );
+
+  return result;
+};
+
+export const getAllPlugins = (timeline: Timeline) => {
+  const allPlugins = Object.values(timeline.plugins);
+  if (allPlugins.length) {
+    return allPlugins.reduce((prev = [], curr = []) => prev.concat(curr));
+  }
+  return [];
+};
+
+export const getPluginsWithFlush = (timeline: Timeline) => {
+  const allPlugins = getAllPlugins(timeline);
+
+  // checking for the existence of .flush()
+  const eventPlugins = allPlugins?.filter(
+    (f) => (f as EventPlugin).flush !== undefined
+  ) as EventPlugin[];
+
+  return eventPlugins;
+};
+
+export const getPluginsWithReset = (timeline: Timeline) => {
+  const allPlugins = getAllPlugins(timeline);
+
+  // checking for the existence of .reset()
+  const eventPlugins = allPlugins?.filter(
+    (f) => (f as EventPlugin).reset !== undefined
+  ) as EventPlugin[];
+
+  return eventPlugins;
+};
+
+type PromiseResult<T> =
+  | {
+      status: 'fulfilled';
+      value: T;
+    }
+  | {
+      status: 'rejected';
+      reason: unknown;
+    };
+
+const settlePromise = async <T>(
+  promise: Promise<T> | T
+): Promise<PromiseResult<T>> => {
+  try {
+    const result = await promise;
+    return {
+      status: 'fulfilled',
+      value: result,
+    };
+  } catch (error) {
+    return {
+      status: 'rejected',
+      reason: error,
+    };
+  }
+};
+
+export const allSettled = async <T>(
+  promises: (Promise<T> | T)[]
+): Promise<PromiseResult<T>[]> => {
+  return Promise.all(promises.map(settlePromise));
+};
+
+export function isNumber(x: unknown): x is number {
+  return typeof x === 'number';
+}
+
+export function isString(x: unknown): x is string {
+  return typeof x === 'string';
+}
+
+export function isBoolean(x: unknown): x is boolean {
+  return typeof x === 'boolean';
+}
+
+export function isDate(value: unknown): value is Date {
+  return (
+    value instanceof Date ||
+    (typeof value === 'object' &&
+      Object.prototype.toString.call(value) === '[object Date]')
+  );
+}
+
+export function objectToString(value: object, json = true): string | undefined {
+  // If the object has a custom toString we well use that
+  if (value.toString !== Object.prototype.toString) {
+    return value.toString();
+  }
+  if (json) {
+    return JSON.stringify(value);
+  }
+  return undefined;
+}
+
+export function unknownToString(
+  value: unknown,
+  stringifyJSON = true,
+  replaceNull: string | undefined = '',
+  replaceUndefined: string | undefined = ''
+): string | undefined {
+  if (value === null) {
+    if (replaceNull !== undefined) {
+      return replaceNull;
+    } else {
+      return undefined;
+    }
+  }
+
+  if (value === undefined) {
+    if (replaceUndefined !== undefined) {
+      return replaceUndefined;
+    } else {
+      return undefined;
+    }
+  }
+
+  if (isNumber(value) || isBoolean(value) || isString(value)) {
+    return value.toString();
+  }
+
+  if (isObject(value)) {
+    return objectToString(value, stringifyJSON);
+  }
+
+  if (stringifyJSON) {
+    return JSON.stringify(value);
+  }
+  return undefined;
+}
+
+/**
+ * Checks if value is a dictionary like object
+ * @param value unknown object
+ * @returns typeguard, value is dicitonary
+ */
+export const isObject = (value: unknown): value is Record<string, unknown> =>
+  value !== null &&
+  value !== undefined &&
+  typeof value === 'object' &&
+  !Array.isArray(value);
+
+/**
+ * Utility to deeply compare 2 objects
+ * @param a unknown object
+ * @param b unknown object
+ * @returns true if both objects have the same keys and values
+ */
+export function deepCompare<T>(a: T, b: T): boolean {
+  // Shallow compare first, just in case
+  if (a === b) {
+    return true;
+  }
+
+  // If not objects then compare values directly
+  if (!isObject(a) || !isObject(b)) {
+    return a === b;
+  }
+
+  const keysA = Object.keys(a);
+  const keysB = Object.keys(b);
+
+  if (keysA.length !== keysB.length) {
+    return false;
+  }
+
+  for (const key of keysA) {
+    if (!keysB.includes(key) || !deepCompare(a[key], b[key])) {
+      return false;
+    }
+  }
+
+  return true;
+}
+
+export const createPromise = <T>(
+  timeout: number | undefined = undefined,
+  _errorHandler: (err: Error) => void = (_: Error) => {
+    //
+  }
+): { promise: Promise<T>; resolve: (value: T) => void } => {
+  let resolver: (value: T) => void;
+  const promise = new Promise<T>((resolve, reject) => {
+    resolver = resolve;
+    if (timeout !== undefined) {
+      setTimeout(() => {
+        reject(new Error('Promise timed out'));
+      }, timeout);
+    }
+  });
+
+  promise.catch(_errorHandler);
+
+  return {
+    promise: promise,
+    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+    resolve: resolver!,
+  };
+};
+
+export function getURL(host: string, path: string) {
+  if (!host.startsWith('https://') && !host.startsWith('http://')) {
+    host = 'https://' + host;
+  }
+  const s = `${host}${path}`;
+  if (!validateURL(s)) {
+    console.error('Invalid URL has been passed');
+    console.log(`Invalid Url passed is ${s}`);
+    throw new Error('Invalid URL has been passed');
+  }
+
+  return s;
+}
+
+export function validateURL(url: string): boolean {
+  const urlRegex = new RegExp(
+    '^(?:https?:\\/\\/)' + // Protocol (http or https)
+      '(?:\\S+(?::\\S*)?@)?' + // Optional user:pass@
+      '(?:(localhost|\\d{1,3}(?:\\.\\d{1,3}){3})|' + // Localhost or IP address
+      '(?:(?!-)[a-zA-Z0-9-]+(?:\\.[a-zA-Z0-9-]+)*(?:\\.[a-zA-Z]{2,})))' + // Domain validation (supports hyphens)
+      '(?::\\d{2,5})?' + // Optional port
+      '(\\/[^\\s?#]*)?' + // Path (allows `/projects/yup/settings`)
+      '(\\?[a-zA-Z0-9_.-]+=[a-zA-Z0-9_.-]+(&[a-zA-Z0-9_.-]+=[a-zA-Z0-9_.-]+)*)?' + // Query params
+      '(#[^\\s]*)?$', // Fragment (optional)
+    'i' // Case-insensitive
+  );
+  return urlRegex.test(url);
+}

package/packages/core/src/uuid.ts

@@ -0,0 +1,7 @@
+import 'react-native-get-random-values';
+import { v4 as uuidv4 } from 'uuid';
+
+export const getUUID = (): string => {
+  const UUID = uuidv4().toString();
+  return UUID;
+};

package/packages/core/tsconfig.json

@@ -0,0 +1,10 @@
+{
+  "extends": "../../tsconfig.json",
+  "compilerOptions": {
+    "outDir": "lib/typescript",
+    "rootDir": ".",
+    "baseUrl": "."
+  },
+  "references": [{ "path": "../sovran" }],
+  "include": ["src/**/*", "src/**/*.json", "types.d.ts"]
+}

package/packages/core/tsconfig.linter.json

@@ -0,0 +1,11 @@
+{
+  "extends": "../../tsconfig",
+  "compilerOptions": {
+    "outDir": "lib/typescript",
+    "rootDir": ".",
+    "baseUrl": "."
+  },
+  "include": ["src/**/*", "types.d.ts"],
+  "exclude": ["**/__fixtures__/**/*", "**/__snapshots__/**/*"],
+  "references": [{ "path": "../sovran" }] // Add refereneces to any packages you require
+}