react-native-nitro-amplitude 0.1.0 → 0.2.0

package/src/analytics/react-native-client.ts

@@ -48,7 +48,7 @@ export type AmplitudeReactNativeClient = ReactNativeClient & {
 };
 
 let nextConnectorOwnerId = 0;
-let activeConnectorOwnerId: number | undefined;
+const activeConnectorOwnerIds = new Map<string, number>();
 
 export class AmplitudeReactNative
   extends AmplitudeCore
@@ -62,7 +62,7 @@ export class AmplitudeReactNative
 
   // @ts-ignore
   config: ReactNativeConfig;
-  userProperties: { [key: string]: any } | undefined;
+  userProperties: Record<string, unknown> | undefined;
 
   init(apiKey = "", userId?: string, options?: ReactNativeOptions) {
     this.initPromise =
@@ -99,7 +99,8 @@ export class AmplitudeReactNative
       // Set up the analytics connector to integrate with the experiment SDK.
       // Send events from the experiment SDK and forward identifies to the
       // identity store.
-      const connector = getAnalyticsConnector();
+      const connectorInstanceName = this.getConnectorInstanceName();
+      const connector = getAnalyticsConnector(connectorInstanceName);
       connector.identityStore.setIdentity({
         userId: this.config.userId,
         deviceId: this.config.deviceId,
@@ -140,7 +141,7 @@ export class AmplitudeReactNative
           this.track(event.eventType, event.eventProperties).promise,
         );
       });
-      activeConnectorOwnerId = this.connectorOwnerId;
+      activeConnectorOwnerIds.set(connectorInstanceName, this.connectorOwnerId);
     } catch (error) {
       if (appStateHandlerInstalled) {
         this.appStateChangeHandler?.remove();
@@ -162,11 +163,18 @@ export class AmplitudeReactNative
     this.dispatchQ = [];
     this.isReady = false;
 
-    if (activeConnectorOwnerId === this.connectorOwnerId) {
-      const connector = getAnalyticsConnector();
+    const connectorInstanceName = this.config
+      ? this.getConnectorInstanceName()
+      : undefined;
+    if (
+      connectorInstanceName &&
+      activeConnectorOwnerIds.get(connectorInstanceName) ===
+        this.connectorOwnerId
+    ) {
+      const connector = getAnalyticsConnector(connectorInstanceName);
       connector.eventBridge.setEventReceiver(() => undefined);
       connector.identityStore.setIdentity({});
-      activeConnectorOwnerId = undefined;
+      activeConnectorOwnerIds.delete(connectorInstanceName);
     }
   }
 
@@ -178,6 +186,10 @@ export class AmplitudeReactNative
     });
   }
 
+  private getConnectorInstanceName() {
+    return this.config.instanceName ?? "$default_instance";
+  }
+
   private cancelDestinationFlushes() {
     this.timeline.plugins.forEach((plugin) => {
       if (plugin.type !== "destination") {
@@ -232,7 +244,7 @@ export class AmplitudeReactNative
       return;
     }
     this.config.userId = userId;
-    setConnectorUserId(userId);
+    setConnectorUserId(userId, this.getConnectorInstanceName());
   }
 
   getDeviceId() {
@@ -245,7 +257,7 @@ export class AmplitudeReactNative
       return;
     }
     this.config.deviceId = deviceId;
-    setConnectorDeviceId(deviceId);
+    setConnectorDeviceId(deviceId, this.getConnectorInstanceName());
   }
 
   identify(identify: IIdentify, eventOptions?: EventOptions) {

package/src/experiment/transport/http.ts

@@ -66,11 +66,19 @@ const _request = (
 ): Promise<SimpleResponse> => {
   const abortController = getAbortController();
   const call = async () => {
-    const response = await getFetch()(requestUrl, {
+    const upperMethod = method.toUpperCase();
+    const init: RequestInit = {
       method: method,
       headers: headers,
-      body: data,
       signal: abortController?.signal,
+    };
+
+    if (upperMethod !== "GET" && upperMethod !== "HEAD") {
+      init.body = data;
+    }
+
+    const response = await getFetch()(requestUrl, {
+      ...init,
     });
     const simpleResponse: SimpleResponse = {
       status: response.status,

package/src/index.ts

@@ -63,4 +63,4 @@ export type { AmplitudeContext } from "./AmplitudeContext.nitro";
 export type { AmplitudeStorage } from "./AmplitudeStorage.nitro";
 export type { AmplitudeWorker } from "./AmplitudeWorker.nitro";
 
-export const VERSION = "0.1.0";
+export const VERSION = "0.2.0";

package/src/index.web.ts

@@ -1,19 +1,66 @@
-const unsupported = (name: string): never => {
-  throw new Error(
-    `react-native-nitro-amplitude: ${name} is not supported on web. Use native iOS/Android builds.`,
-  );
-};
+import analyticsClient, {
+  createInstance,
+} from "./analytics/react-native-client";
+import { prefetchNativeContext } from "./native/context";
 
-export const init = () => unsupported("init");
-export const track = () => unsupported("track");
-export const identify = () => unsupported("identify");
-export const createInstance = () => unsupported("createInstance");
-export const Experiment = {
-  initialize: () => unsupported("Experiment.initialize"),
-  initializeWithAmplitudeAnalytics: () =>
-    unsupported("Experiment.initializeWithAmplitudeAnalytics"),
-};
+import * as AnalyticsTypes from "./analytics/types";
+
+export { createInstance };
+export const {
+  add,
+  flush,
+  getDeviceId,
+  getSessionId,
+  getUserId,
+  groupIdentify,
+  identify,
+  init,
+  logEvent,
+  remove,
+  reset,
+  revenue,
+  setDeviceId,
+  setGroup,
+  setOptOut,
+  setSessionId,
+  setUserId,
+  shutdown,
+  track,
+  extendSession,
+} = analyticsClient;
+
+export { Revenue, Identify } from "@amplitude/analytics-core";
+export {
+  InMemoryStorage,
+  LocalStorage,
+  MemoryStorage,
+} from "./analytics/storage/local-storage";
+export { NitroAnalyticsStorage, NitroMemoryStorage } from "./native/storage";
+export { nitroHttpClient } from "./native/http";
+export { nitroTransport } from "./analytics/nitro-transport";
+export { prefetchNativeContext };
+export { AnalyticsTypes as Types };
+
+export * from "./experiment/types/config";
+export { Experiment } from "./experiment/factory";
+export { StubExperimentClient } from "./experiment/stubClient";
+export { ExperimentClient } from "./experiment/experimentClient";
+export * from "./experiment/types/client";
+export { Source } from "./experiment/types/source";
+export * from "./experiment/types/user";
+export * from "./experiment/types/variant";
+export * from "./experiment/types/exposure";
+export * from "./experiment/types/storage";
+export { LogLevel } from "./experiment/types/logger";
+export type { Logger } from "./experiment/types/logger";
+export { ConsoleLogger } from "./experiment/logger/consoleLogger";
+export {
+  LocalStorage as ExperimentLocalStorage,
+  MemoryStorage as ExperimentMemoryStorage,
+} from "./experiment/storage/local-storage";
 
 export type { AmplitudeContext } from "./AmplitudeContext.nitro";
 export type { AmplitudeStorage } from "./AmplitudeStorage.nitro";
 export type { AmplitudeWorker } from "./AmplitudeWorker.nitro";
+
+export const VERSION = "0.2.0";

package/src/native/context.web.ts

@@ -0,0 +1,38 @@
+import type { ReactNativeTrackingOptions } from "@amplitude/analytics-core";
+import type { LegacySessionData, NativeApplicationContext } from "./context";
+
+type NavigatorWithLanguage = Navigator & {
+  userLanguage?: string;
+};
+
+export function prefetchNativeContext(): void {}
+
+export function getNativeApplicationContext(
+  _options: ReactNativeTrackingOptions,
+): NativeApplicationContext {
+  const browserNavigator =
+    typeof navigator === "undefined"
+      ? undefined
+      : (navigator as NavigatorWithLanguage);
+  return {
+    platform: "Web",
+    language: browserNavigator?.language ?? browserNavigator?.userLanguage,
+  };
+}
+
+export function getLegacySessionData(_instanceName: string): LegacySessionData {
+  return {};
+}
+
+export function getLegacyEvents(
+  _instanceName: string,
+  _eventKind: string,
+): string[] {
+  return [];
+}
+
+export function removeLegacyEvent(
+  _instanceName: string,
+  _eventKind: string,
+  _eventId: number,
+): void {}

package/src/native/http.web.ts

@@ -0,0 +1,22 @@
+import { FetchHttpClient } from "../experiment/transport/http";
+import type { HttpClient, SimpleResponse } from "../experiment/types/transport";
+
+export class NitroHttpClient implements HttpClient {
+  request(
+    requestUrl: string,
+    method: string,
+    headers: Record<string, string>,
+    data: string | null,
+    timeoutMillis = 10000,
+  ): Promise<SimpleResponse> {
+    return FetchHttpClient.request(
+      requestUrl,
+      method,
+      headers,
+      data ?? "",
+      timeoutMillis,
+    );
+  }
+}
+
+export const nitroHttpClient = new NitroHttpClient();

package/src/native/storage.web.ts

@@ -0,0 +1,152 @@
+import type { Storage as AnalyticsStorage } from "@amplitude/analytics-core";
+import type { Storage as ExperimentStorage } from "../experiment/types/storage";
+
+function namespaceKey(namespace: string, key: string): string {
+  return `${namespace}::${key}`;
+}
+
+class WebStringStorage {
+  private static readonly memory = new Map<string, string>();
+
+  constructor(private readonly namespace: string) {}
+
+  get(key: string): string | undefined {
+    const storageKey = namespaceKey(this.namespace, key);
+    try {
+      if (typeof localStorage !== "undefined") {
+        return localStorage.getItem(storageKey) ?? undefined;
+      }
+    } catch {}
+    return WebStringStorage.memory.get(storageKey);
+  }
+
+  set(key: string, value: string): void {
+    const storageKey = namespaceKey(this.namespace, key);
+    WebStringStorage.memory.set(storageKey, value);
+    try {
+      if (typeof localStorage !== "undefined") {
+        localStorage.setItem(storageKey, value);
+      }
+    } catch {}
+  }
+
+  remove(key: string): void {
+    const storageKey = namespaceKey(this.namespace, key);
+    WebStringStorage.memory.delete(storageKey);
+    try {
+      if (typeof localStorage !== "undefined") {
+        localStorage.removeItem(storageKey);
+      }
+    } catch {}
+  }
+
+  reset(): void {
+    const prefix = `${this.namespace}::`;
+    for (const key of WebStringStorage.memory.keys()) {
+      if (key.startsWith(prefix)) {
+        WebStringStorage.memory.delete(key);
+      }
+    }
+    try {
+      if (typeof localStorage !== "undefined") {
+        for (let index = localStorage.length - 1; index >= 0; index--) {
+          const key = localStorage.key(index);
+          if (key?.startsWith(prefix)) {
+            localStorage.removeItem(key);
+          }
+        }
+      }
+    } catch {}
+  }
+}
+
+export class NitroAnalyticsStorage<T> implements AnalyticsStorage<T> {
+  private readonly storage: WebStringStorage;
+
+  constructor(namespace: string) {
+    this.storage = new WebStringStorage(namespace);
+  }
+
+  async isEnabled(): Promise<boolean> {
+    return true;
+  }
+
+  async get(key: string): Promise<T | undefined> {
+    const raw = await this.getRaw(key);
+    if (!raw) {
+      return undefined;
+    }
+    try {
+      return JSON.parse(raw) as T;
+    } catch {
+      return undefined;
+    }
+  }
+
+  async getRaw(key: string): Promise<string | undefined> {
+    return this.storage.get(key);
+  }
+
+  async set(key: string, value: T): Promise<void> {
+    this.storage.set(key, JSON.stringify(value));
+  }
+
+  async remove(key: string): Promise<void> {
+    this.storage.remove(key);
+  }
+
+  async reset(): Promise<void> {
+    this.storage.reset();
+  }
+}
+
+export class NitroExperimentStorage implements ExperimentStorage {
+  private readonly storage: WebStringStorage;
+
+  constructor(namespace: string) {
+    this.storage = new WebStringStorage(namespace);
+  }
+
+  async get(key: string): Promise<string | null> {
+    return this.storage.get(key) ?? null;
+  }
+
+  async put(key: string, value: string): Promise<void> {
+    this.storage.set(key, value);
+  }
+
+  async delete(key: string): Promise<void> {
+    this.storage.remove(key);
+  }
+
+  async reset(): Promise<void> {
+    this.storage.reset();
+  }
+}
+
+export class NitroMemoryStorage implements ExperimentStorage {
+  private readonly values = new Map<string, string>();
+
+  constructor(private readonly namespace: string) {}
+
+  async get(key: string): Promise<string | null> {
+    return this.values.get(namespaceKey(this.namespace, key)) ?? null;
+  }
+
+  async put(key: string, value: string): Promise<void> {
+    this.values.set(namespaceKey(this.namespace, key), value);
+  }
+
+  async delete(key: string): Promise<void> {
+    this.values.delete(namespaceKey(this.namespace, key));
+  }
+
+  async reset(): Promise<void> {
+    const prefix = `${this.namespace}::`;
+    for (const key of this.values.keys()) {
+      if (key.startsWith(prefix)) {
+        this.values.delete(key);
+      }
+    }
+  }
+}