@amplitude/analytics-react-native 0.0.1-dev.0

package/src/storage/utm-cookie.ts

@@ -0,0 +1,27 @@
+import { CookieStorage } from './cookie';
+
+export class UTMCookie extends CookieStorage<Record<string, string | undefined>> {
+  async get(key: string): Promise<Record<string, string | undefined> | undefined> {
+    try {
+      const value = await this.getRaw(key);
+      if (!value) {
+        return undefined;
+      }
+      const entries = value.split('.').splice(-1)[0].split('|');
+      return entries.reduce<Record<string, string | undefined>>((acc, curr) => {
+        const [key, value = ''] = curr.split('=', 2);
+        if (!value) {
+          return acc;
+        }
+        acc[key] = decodeURIComponent(value);
+        return acc;
+      }, {});
+    } catch {
+      return undefined;
+    }
+  }
+
+  async set(): Promise<void> {
+    return undefined;
+  }
+}

package/src/transports/fetch.ts

@@ -0,0 +1,23 @@
+import { BaseTransport } from '@amplitude/analytics-core';
+import { Payload, Response, Transport } from '@amplitude/analytics-types';
+
+export class FetchTransport extends BaseTransport implements Transport {
+  async send(serverUrl: string, payload: Payload): Promise<Response | null> {
+    /* istanbul ignore if */
+    if (typeof fetch === 'undefined') {
+      throw new Error('FetchTransport is not supported');
+    }
+    const options: RequestInit = {
+      headers: {
+        'Content-Type': 'application/json',
+        Accept: '*/*',
+      },
+      body: JSON.stringify(payload),
+      method: 'POST',
+    };
+    const response = await fetch(serverUrl, options);
+    // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+    const responsePayload: Record<string, any> = await response.json();
+    return this.buildResponse(responsePayload);
+  }
+}

package/src/transports/send-beacon.ts

@@ -0,0 +1,34 @@
+import { BaseTransport } from '@amplitude/analytics-core';
+import { Payload, Response, Transport } from '@amplitude/analytics-types';
+
+export class SendBeaconTransport extends BaseTransport implements Transport {
+  async send(serverUrl: string, payload: Payload): Promise<Response | null> {
+    return new Promise((resolve, reject) => {
+      /* istanbul ignore if */
+      if (
+        typeof window === 'undefined' ||
+        typeof window.navigator === 'undefined' ||
+        typeof window.navigator.sendBeacon === 'undefined'
+      ) {
+        throw new Error('SendBeaconTransport is not supported');
+      }
+      try {
+        const data = JSON.stringify(payload);
+        const success = window.navigator.sendBeacon(serverUrl, JSON.stringify(payload));
+        if (success) {
+          return resolve(
+            this.buildResponse({
+              code: 200,
+              events_ingested: payload.events.length,
+              payload_size_bytes: data.length,
+              server_upload_time: Date.now(),
+            }),
+          );
+        }
+        return resolve(this.buildResponse({ code: 500 }));
+      } catch (e) {
+        reject(e);
+      }
+    });
+  }
+}

package/src/transports/xhr.ts

@@ -0,0 +1,36 @@
+import { BaseTransport } from '@amplitude/analytics-core';
+import { Payload, Response, Transport } from '@amplitude/analytics-types';
+
+export class XHRTransport extends BaseTransport implements Transport {
+  private state = {
+    done: 4,
+  };
+
+  async send(serverUrl: string, payload: Payload): Promise<Response | null> {
+    return new Promise((resolve, reject) => {
+      /* istanbul ignore if */
+      if (typeof XMLHttpRequest === 'undefined') {
+        reject(new Error('XHRTransport is not supported.'));
+      }
+
+      const xhr = new XMLHttpRequest();
+      xhr.open('POST', serverUrl, true);
+      xhr.onreadystatechange = () => {
+        if (xhr.readyState === this.state.done) {
+          try {
+            const responsePayload = xhr.responseText;
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            const parsedResponsePayload: Record<string, any> = JSON.parse(responsePayload);
+            const result = this.buildResponse(parsedResponsePayload);
+            resolve(result);
+          } catch (e) {
+            reject(e);
+          }
+        }
+      };
+      xhr.setRequestHeader('Content-Type', 'application/json');
+      xhr.setRequestHeader('Accept', '*/*');
+      xhr.send(JSON.stringify(payload));
+    });
+  }
+}

package/src/typings/browser-snippet.d.ts

@@ -0,0 +1,7 @@
+import { InstanceProxy } from '@amplitude/analytics-types';
+
+declare global {
+  // globalThis only includes `var` declarations
+  // eslint-disable-next-line no-var
+  var amplitude: InstanceProxy & { invoked: boolean };
+}

package/src/typings/ua-parser.d.ts

@@ -0,0 +1,4 @@
+declare module '@amplitude/ua-parser-js' {
+  import UAParser from 'ua-parser-js';
+  export = UAParser;
+}

package/src/utils/cookie-name.ts

@@ -0,0 +1,9 @@
+import { AMPLITUDE_PREFIX } from '@amplitude/analytics-core';
+
+export const getCookieName = (apiKey: string, postKey = '', limit = 10) => {
+  return [AMPLITUDE_PREFIX, postKey, apiKey.substring(0, limit)].filter(Boolean).join('_');
+};
+
+export const getOldCookieName = (apiKey: string) => {
+  return `${AMPLITUDE_PREFIX.toLowerCase()}_${apiKey.substring(0, 6)}`;
+};

package/src/utils/language.ts

@@ -0,0 +1,7 @@
+export const getLanguage = (): string => {
+  if (typeof navigator === 'undefined') return '';
+  // eslint-disable-next-line @typescript-eslint/no-unsafe-member-access
+  const userLanguage = (navigator as any).userLanguage as string | undefined;
+
+  return navigator.languages?.[0] ?? navigator.language ?? userLanguage ?? '';
+};

package/src/utils/platform.ts

@@ -0,0 +1,9 @@
+import { Platform } from 'react-native';
+
+export const isWeb = (): boolean => {
+  return Platform.OS === 'web';
+};
+
+export const isNative = (): boolean => {
+  return !isWeb();
+};

package/src/utils/query-params.ts

@@ -0,0 +1,21 @@
+import { isNative } from './platform';
+
+export const getQueryParams = (): Record<string, string | undefined> => {
+  if (isNative()) {
+    return {};
+  }
+  /* istanbul ignore if */
+  if (typeof window === 'undefined') {
+    return {};
+  }
+  const pairs = window.location.search.substring(1).split('&').filter(Boolean);
+  const params = pairs.reduce<Record<string, string | undefined>>((acc, curr) => {
+    const [key, value = ''] = curr.split('=', 2);
+    if (!value) {
+      return acc;
+    }
+    acc[decodeURIComponent(key)] = decodeURIComponent(value);
+    return acc;
+  }, {});
+  return params;
+};

package/src/utils/snippet-helper.ts

@@ -0,0 +1,35 @@
+import { AmplitudeReturn, InstanceProxy, QueueProxy, Result } from '@amplitude/analytics-types';
+
+/**
+ * Applies the proxied functions on the proxied amplitude snippet to an instance of the real object.
+ * @ignore
+ */
+export const runQueuedFunctions = (instance: object, queue: QueueProxy) => {
+  convertProxyObjectToRealObject(instance, queue);
+};
+
+/**
+ * Applies the proxied functions on the proxied object to an instance of the real object.
+ * Used to convert proxied Identify and Revenue objects.
+ */
+export const convertProxyObjectToRealObject = <T>(instance: T, queue: QueueProxy): T => {
+  for (let i = 0; i < queue.length; i++) {
+    const { name, args, resolve } = queue[i];
+    const fn = instance && instance[name as keyof T];
+    if (typeof fn === 'function') {
+      const result = fn.apply(instance, args) as AmplitudeReturn<Result>;
+      if (typeof resolve === 'function') {
+        resolve(result?.promise);
+      }
+    }
+  }
+  return instance;
+};
+
+/**
+ * Check if the param is snippet proxy
+ */
+export const isInstanceProxy = (instance: unknown): instance is InstanceProxy => {
+  const instanceProxy = instance as InstanceProxy;
+  return instanceProxy && instanceProxy._q !== undefined;
+};

package/src/version.ts

@@ -0,0 +1 @@
+export const VERSION = '0.0.1-dev.0';