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

package/src/storage/cookie.ts

@@ -0,0 +1,97 @@
+import { Storage, CookieStorageOptions } from '@amplitude/analytics-types';
+import { isNative } from '../utils/platform';
+
+export class CookieStorage<T> implements Storage<T> {
+  options: CookieStorageOptions;
+
+  constructor(options?: CookieStorageOptions) {
+    this.options = { ...options };
+  }
+
+  async isEnabled(): Promise<boolean> {
+    /* istanbul ignore if */
+    if (isNative() || typeof window === 'undefined') {
+      return false;
+    }
+
+    const random = String(Date.now());
+    const testStrorage = new CookieStorage<string>();
+    const testKey = 'AMP_TEST';
+    try {
+      await testStrorage.set(testKey, random);
+      const value = await testStrorage.get(testKey);
+      return value === random;
+    } catch {
+      /* istanbul ignore next */
+      return false;
+    } finally {
+      await testStrorage.remove(testKey);
+    }
+  }
+
+  async get(key: string): Promise<T | undefined> {
+    let value = await this.getRaw(key);
+    if (!value) {
+      return undefined;
+    }
+    try {
+      try {
+        value = decodeURIComponent(atob(value));
+      } catch {
+        // value not encoded
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+      return JSON.parse(value);
+    } catch {
+      /* istanbul ignore next */
+      return undefined;
+    }
+  }
+
+  async getRaw(key: string): Promise<string | undefined> {
+    const cookie = window.document.cookie.split('; ');
+    const match = cookie.find((c) => c.indexOf(key + '=') === 0);
+    if (!match) {
+      return undefined;
+    }
+    return match.substring(key.length + 1);
+  }
+
+  async set(key: string, value: T | null): Promise<void> {
+    try {
+      const expirationDays = this.options.expirationDays ?? 0;
+      const expires = value !== null ? expirationDays : -1;
+      let expireDate: Date | undefined = undefined;
+      if (expires) {
+        const date = new Date();
+        date.setTime(date.getTime() + expires * 24 * 60 * 60 * 1000);
+        expireDate = date;
+      }
+      let str = `${key}=${btoa(encodeURIComponent(JSON.stringify(value)))}`;
+      if (expireDate) {
+        str += `; expires=${expireDate.toUTCString()}`;
+      }
+      str += '; path=/';
+      if (this.options.domain) {
+        str += `; domain=${this.options.domain}`;
+      }
+      if (this.options.secure) {
+        str += '; Secure';
+      }
+      if (this.options.sameSite) {
+        str += `; SameSite=${this.options.sameSite}`;
+      }
+      window.document.cookie = str;
+    } catch {
+      //
+    }
+  }
+
+  async remove(key: string): Promise<void> {
+    await this.set(key, null);
+  }
+
+  async reset(): Promise<void> {
+    return;
+  }
+}

package/src/storage/local-storage.ts

@@ -0,0 +1,67 @@
+import { Storage } from '@amplitude/analytics-types';
+import AsyncStorage from '@react-native-async-storage/async-storage';
+
+export class LocalStorage<T> implements Storage<T> {
+  async isEnabled(): Promise<boolean> {
+    /* istanbul ignore if */
+    if (typeof window === 'undefined') {
+      return false;
+    }
+
+    const random = String(Date.now());
+    const testStorage = new LocalStorage<string>();
+    const testKey = 'AMP_TEST';
+    try {
+      await testStorage.set(testKey, random);
+      const value = await testStorage.get(testKey);
+      return value === random;
+    } catch {
+      /* istanbul ignore next */
+      return false;
+    } finally {
+      await testStorage.remove(testKey);
+    }
+  }
+
+  async get(key: string): Promise<T | undefined> {
+    try {
+      const value = await this.getRaw(key);
+      if (!value) {
+        return undefined;
+      }
+      // eslint-disable-next-line @typescript-eslint/no-unsafe-return
+      return JSON.parse(value);
+    } catch {
+      /* istanbul ignore next */
+      return undefined;
+    }
+  }
+
+  async getRaw(key: string): Promise<string | undefined> {
+    return (await AsyncStorage.getItem(key)) || undefined;
+  }
+
+  async set(key: string, value: T): Promise<void> {
+    try {
+      await AsyncStorage.setItem(key, JSON.stringify(value));
+    } catch {
+      //
+    }
+  }
+
+  async remove(key: string): Promise<void> {
+    try {
+      await AsyncStorage.removeItem(key);
+    } catch {
+      //
+    }
+  }
+
+  async reset(): Promise<void> {
+    try {
+      await AsyncStorage.clear();
+    } catch {
+      //
+    }
+  }
+}

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/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/analytics-connector.ts

@@ -0,0 +1,5 @@
+import { AnalyticsConnector } from '@amplitude/analytics-connector';
+
+export const getAnalyticsConnector = (): AnalyticsConnector => {
+  return AnalyticsConnector.getInstance('$default_instance');
+};

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,18 @@
+import { isNative } from './platform';
+
+export const getQueryParams = (): Record<string, string | undefined> => {
+  /* istanbul ignore if */
+  if (isNative() || 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/version.ts

@@ -0,0 +1 @@
+export const VERSION = '0.1.0';