@gabagool-sdk/react-native 0.0.0-stage → 0.1.0

package/src/adapter.ts

@@ -0,0 +1,193 @@
+import mobileAds, {
+  AdEventType,
+  AppOpenAd,
+  GAMInterstitialAd,
+  InterstitialAd,
+  RewardedAd,
+  RewardedAdEventType,
+  RevenuePrecisions,
+} from 'react-native-google-mobile-ads';
+import { numericCode } from './errors.js';
+import {
+  networkOf,
+  type AdFormat,
+  type AdHandle,
+  type AdNetworkAdapter,
+  type FloorKV,
+  type LoadResult,
+  type ShowResult,
+} from '@gabagool-sdk/core';
+type RequestOptions = { customTargeting?: Record<string, string | number | (string | number)[]> };
+
+type Remove = () => void;
+type EventPayload = Error & { code?: string; reason?: string; phase?: 'load' | 'show' };
+type PaidPayload = {
+  currency: string;
+  precision: RevenuePrecisions;
+  value: number;
+  valueMicros?: string | null;
+  responseInfo?: { loadedAdapterResponse?: { adSourceName?: string | null } | null };
+};
+type NativeFullscreen = {
+  load(): void;
+  show(): Promise<void>;
+  destroy(): void;
+  addAdEventListener(type: string, listener: (payload: never) => void): Remove;
+  responseInfo: { loadedAdapterResponse?: { adSourceName?: string | null } | null } | null;
+};
+
+const precisionName = (value: RevenuePrecisions): string => ({
+  [RevenuePrecisions.ESTIMATED]: 'estimated',
+  [RevenuePrecisions.PRECISE]: 'precise',
+  [RevenuePrecisions.PUBLISHER_PROVIDED]: 'publisher_provided',
+  [RevenuePrecisions.UNKNOWN]: 'unknown',
+})[value] ?? 'unknown';
+
+
+/** Adapter do core para a API estável do Invertase 17.x. */
+export class ReactNativeGmaAdapter implements AdNetworkAdapter {
+  private sequence = 0;
+  private readonly nativeAds = new Map<string, NativeFullscreen>();
+  private readonly bannerFailures = new Map<string, number>();
+
+  /** Banner é componente: o resultado real chega por onAdLoaded/onAdFailedToLoad (core.trackBannerLoad). */
+  readonly bannerLoadReportedByComponent = true;
+
+  /** Falha do initialize() não trava o app (como a Dart): segue e os loads reportam seus próprios erros. */
+  async initialize(): Promise<void> {
+    try { await mobileAds().initialize(); } catch { /* segue sem travar */ }
+  }
+
+  loadInterstitial(adUnit: string, floorKV?: FloorKV): Promise<LoadResult> {
+    return this.loadFullscreen('interstitial', adUnit, floorKV);
+  }
+  loadRewarded(adUnit: string, floorKV?: FloorKV): Promise<LoadResult> {
+    return this.loadFullscreen('rewarded', adUnit, floorKV);
+  }
+  loadAppOpen(adUnit: string, floorKV?: FloorKV): Promise<LoadResult> {
+    return this.loadFullscreen('app_open', adUnit, floorKV);
+  }
+
+  async loadBanner(adUnit: string, _floorKV?: FloorKV): Promise<LoadResult> {
+    const failures = this.bannerFailures.get(adUnit) ?? 0;
+    if (failures > 0) {
+      if (failures === 1) this.bannerFailures.delete(adUnit);
+      else this.bannerFailures.set(adUnit, failures - 1);
+      return { status: 'no_fill', code: 3 };
+    }
+    // Banner é um componente no Invertase. O handle descreve o componente que a fachada renderizará.
+    return { status: 'fill', ad: this.handle('banner', adUnit) };
+  }
+
+  /** Native ainda não portado para RN (Invertase NativeAd): reporta erro explícito, nunca fill falso. */
+  async loadNative(_adUnit: string, _floorKV?: FloorKV): Promise<LoadResult> {
+    return { status: 'error', error: 'native_not_supported_react_native' };
+  }
+
+  markBannerFailed(ad: AdHandle): void {
+    this.bannerFailures.set(ad.adUnit, (this.bannerFailures.get(ad.adUnit) ?? 0) + 1);
+  }
+
+  async setTestDeviceIds(ids: string[]): Promise<void> {
+    await mobileAds().setRequestConfiguration({ testDeviceIdentifiers: [...ids] });
+  }
+
+  dispose(ad: AdHandle): void {
+    const native = this.nativeAds.get(ad.id);
+    native?.destroy();
+    this.nativeAds.delete(ad.id);
+  }
+
+  show(ad: AdHandle): Promise<ShowResult> {
+    const native = this.nativeAds.get(ad.id);
+    if (!native) return Promise.resolve({ status: 'error', error: 'ad_handle_not_found' });
+    return new Promise((resolve) => {
+      let earned = false;
+      let paid: Omit<ShowResult, 'status'> = {};
+      let settled = false;
+      const removers: Remove[] = [];
+      const finish = (result: ShowResult) => {
+        if (settled) return;
+        settled = true;
+        removers.forEach((remove) => remove());
+        native.destroy();
+        this.nativeAds.delete(ad.id);
+        resolve(result);
+      };
+      removers.push(native.addAdEventListener(AdEventType.PAID, ((event: PaidPayload) => {
+        const exact = event.valueMicros == null ? undefined : Number(event.valueMicros);
+        paid = {
+          paidValue: event.value,
+          ...(Number.isFinite(exact) ? { paidMicros: exact } : { paidMicros: Math.round(event.value * 1_000_000) }),
+          currency: event.currency,
+          precision: precisionName(event.precision),
+          adSource: event.responseInfo?.loadedAdapterResponse?.adSourceName
+            ?? native.responseInfo?.loadedAdapterResponse?.adSourceName ?? undefined,
+        };
+      }) as (payload: never) => void));
+      if (ad.format === 'rewarded') {
+        removers.push(native.addAdEventListener(RewardedAdEventType.EARNED_REWARD, (() => { earned = true; }) as (payload: never) => void));
+      }
+      removers.push(native.addAdEventListener(AdEventType.ERROR, ((error: EventPayload) =>
+        finish({ status: 'error', error: error.message || 'show_failed', ...paid })) as (payload: never) => void));
+      removers.push(native.addAdEventListener(AdEventType.CLOSED, (() =>
+        finish({ status: ad.format === 'rewarded' && earned ? 'earned' : 'closed', ...paid })) as (payload: never) => void));
+      try { void native.show().catch((error: unknown) => finish({ status: 'error', error: String(error), ...paid })); }
+      catch (error) { finish({ status: 'error', error: String(error), ...paid }); }
+    });
+  }
+
+  private loadFullscreen(format: Exclude<AdFormat, 'banner'>, adUnit: string, floorKV?: FloorKV): Promise<LoadResult> {
+    return new Promise((resolve) => {
+      let native: NativeFullscreen;
+      try {
+        const request = this.requestOptions(adUnit, floorKV);
+        const created = format === 'app_open'
+          ? AppOpenAd.createForAdRequest(adUnit, request)
+          : format === 'rewarded'
+            ? RewardedAd.createForAdRequest(adUnit, request)
+            : networkOf(adUnit) === 'gam'
+              ? GAMInterstitialAd.createForAdRequest(adUnit, request)
+              : InterstitialAd.createForAdRequest(adUnit, request);
+        native = created as unknown as NativeFullscreen;
+      } catch (error) {
+        resolve({ status: 'error', error: String(error) });
+        return;
+      }
+      let settled = false;
+      const removers: Remove[] = [];
+      const finish = (result: LoadResult) => {
+        if (settled) return;
+        settled = true;
+        removers.forEach((remove) => remove());
+        if (result.status !== 'fill') native.destroy();
+        resolve(result);
+      };
+      const loadedEvent = format === 'rewarded' ? RewardedAdEventType.LOADED : AdEventType.LOADED;
+      removers.push(native.addAdEventListener(loadedEvent, (() => {
+        const handle = this.handle(format, adUnit, this.requestFloor(adUnit, floorKV));
+        this.nativeAds.set(handle.id, native);
+        finish({ status: 'fill', ad: handle });
+      }) as (payload: never) => void));
+      removers.push(native.addAdEventListener(AdEventType.ERROR, ((error: EventPayload) => {
+        const code = numericCode(error);
+        if (code === 3) finish({ status: 'no_fill', code });
+        else finish({ status: 'error', error: error.message || error.reason || 'load_failed', ...(code === undefined ? {} : { code }) });
+      }) as (payload: never) => void));
+      try { native.load(); } catch (error) { finish({ status: 'error', error: String(error) }); }
+    });
+  }
+
+  private requestOptions(adUnit: string, floorKV?: FloorKV): RequestOptions | undefined {
+    const kv = this.requestFloor(adUnit, floorKV);
+    return kv ? { customTargeting: kv } : undefined;
+  }
+
+  private requestFloor(adUnit: string, floorKV?: FloorKV): FloorKV | undefined {
+    return networkOf(adUnit) === 'gam' && floorKV && Object.keys(floorKV).length > 0 ? { ...floorKV } : undefined;
+  }
+
+  private handle(format: AdFormat, adUnit: string, floorKV?: FloorKV): AdHandle {
+    return { id: `rn-gma-${++this.sequence}`, format, adUnit, ...(floorKV ? { floorKV } : {}) };
+  }
+}

package/src/bannerFlow.ts

@@ -0,0 +1,73 @@
+import type { AdHandle } from '@gabagool-sdk/core';
+import { bannerFailureStatus, type LoadErrorLike } from './errors.js';
+
+export interface BannerFlowPorts {
+  /** resolve quando o init da fachada terminou (Banner pode montar antes do init). */
+  ready(): Promise<unknown>;
+  bannerFor(screen: string, slot: string): Promise<AdHandle | null>;
+  markFailed(ad: AdHandle): void;
+  trackLoad(unit: string, status: 'fill' | 'no_fill' | 'error'): void;
+}
+
+export interface BannerFlowHooks {
+  setHandle(handle: AdHandle | null): void;
+  onLoaded?(): void;
+  onFailedToLoad?(error: Error): void;
+}
+
+/** Máximo de requests por montagem: primário + `<slot>_fallback` (nunca volta ao primário, como a Dart). */
+export const MAX_BANNER_ATTEMPTS = 2;
+
+/** Lógica do Banner sem React: primário -> fallback, banner_load real e nenhuma rejeição solta. */
+export class BannerFlow {
+  private generation = 0;
+  private attempts = 0;
+  private handle: AdHandle | null = null;
+
+  constructor(
+    private readonly ports: BannerFlowPorts,
+    private readonly screen: string,
+    private readonly slot: string,
+    private readonly hooks: BannerFlowHooks,
+  ) {}
+
+  start(): void {
+    this.generation++;
+    this.attempts = 0;
+    this.request();
+  }
+
+  stop(): void { this.generation++; }
+
+  loaded(): void {
+    if (!this.handle) return;
+    this.safe(() => this.ports.trackLoad(this.handle!.adUnit, 'fill'));
+    this.hooks.onLoaded?.();
+  }
+
+  failed(error: Error & LoadErrorLike): void {
+    const failed = this.handle;
+    if (!failed) return;
+    this.safe(() => this.ports.trackLoad(failed.adUnit, bannerFailureStatus(error)));
+    this.hooks.onFailedToLoad?.(error);
+    this.attempts++;
+    if (this.attempts >= MAX_BANNER_ATTEMPTS) { this.set(null); return; }
+    this.safe(() => this.ports.markFailed(failed));
+    this.request();
+  }
+
+  private request(): void {
+    const generation = this.generation;
+    void this.ports.ready()
+      .then(() => this.ports.bannerFor(this.screen, this.slot))
+      .then((next) => { if (generation === this.generation) this.set(next); })
+      .catch(() => { if (generation === this.generation) this.set(null); });
+  }
+
+  private set(handle: AdHandle | null): void {
+    this.handle = handle;
+    this.hooks.setHandle(handle);
+  }
+
+  private safe(fn: () => void): void { try { fn(); } catch { /* telemetria nunca derruba o banner */ } }
+}

package/src/errors.ts

@@ -0,0 +1,12 @@
+export type LoadErrorLike = { code?: string; reason?: string };
+
+/** Código numérico do erro de load do Invertase (3 = no fill); undefined se não reconhecido. */
+export const numericCode = (error: LoadErrorLike): number | undefined => {
+  if (error.reason === 'no-fill' || error.reason === 'mediation-no-fill') return 3;
+  const match = error.code?.match(/(?:^|\/)(\d+)$/);
+  return match ? Number(match[1]) : undefined;
+};
+
+/** Status de `banner_load` para uma falha do componente. */
+export const bannerFailureStatus = (error: LoadErrorLike): 'no_fill' | 'error' =>
+  numericCode(error) === 3 ? 'no_fill' : 'error';

package/src/facade.ts

@@ -0,0 +1,150 @@
+import { AdsConsent } from 'react-native-google-mobile-ads';
+import { Dimensions, Platform } from 'react-native';
+import {
+  createGabagool,
+  fallbackConfig,
+  type AdHandle,
+  type AdNetworkAdapter,
+  type BootAdResult,
+  type FetchLike,
+  type Gabagool,
+  type GateResult,
+  type InterstitialShowResult,
+  type KVStorage,
+  type RewardedResult,
+  type TelemetryTransport,
+  type WrapperConfig,
+} from '@gabagool-sdk/core';
+import { ReactNativeGmaAdapter } from './adapter.js';
+import { ReactNativeInstallInfoProvider, type InstallInfoProvider } from './installInfo.js';
+import { AppStateLifecycle } from './lifecycle.js';
+import { AsyncStorageAdapter } from './storage.js';
+import { createReactNativeTransport, reactNativeFetch } from './transport.js';
+
+export interface GabagoolInitOptions {
+  adapter?: AdNetworkAdapter;
+  storage?: KVStorage;
+  fetch?: FetchLike;
+  transport?: TelemetryTransport;
+  requestConsent?: boolean;
+  preload?: boolean;
+  installInfoProvider?: InstallInfoProvider;
+  installReferrer?: string;
+  installBeginTimestampSeconds?: number;
+  installTimeProvider?: () => Promise<number | null | undefined> | number | null | undefined;
+  deepLink?: string;
+  override?: Record<string, string>;
+  fallback?: WrapperConfig;
+  appVersion?: string;
+  deviceModel?: string;
+  advertisingId?: string;
+  debug?: boolean;
+  context?: Record<string, unknown>;
+}
+
+/** Fachada singleton equivalente à fachada Dart. */
+export class GabagoolAds {
+  private static instance: Gabagool = createGabagool();
+  private static lifecycle: AppStateLifecycle | null = null;
+  private static gmaAdapter: ReactNativeGmaAdapter | null = null;
+  private static readyState = GabagoolAds.newReady();
+
+  private static newReady(): { done: boolean; promise: Promise<void>; resolve: () => void } {
+    let resolve!: () => void;
+    const promise = new Promise<void>((r) => { resolve = r; });
+    return { done: false, promise, resolve };
+  }
+
+  /** Resolve quando o `init` terminou (Banner pode montar antes; ver BannerFlow). Nunca rejeita. */
+  static whenReady(): Promise<void> { return this.readyState.promise; }
+
+  private static resetReady(): void {
+    if (this.readyState.done) this.readyState = this.newReady();
+  }
+
+  static get core(): Gabagool { return this.instance; }
+
+  static async init(apiKey: string, baseUrl: string, appId: string, options: GabagoolInitOptions = {}): Promise<void> {
+    this.lifecycle?.stop();
+    this.instance.dispose();
+    this.resetReady();
+    this.instance = createGabagool();
+
+    const adapter = options.adapter ?? new ReactNativeGmaAdapter();
+    this.gmaAdapter = adapter instanceof ReactNativeGmaAdapter ? adapter : null;
+    if (this.gmaAdapter) await this.gmaAdapter.initialize();
+
+    if (options.requestConsent) {
+      // UMP é deliberadamente assíncrono: falha/formulário não bloqueia o fluxo de anúncios.
+      void AdsConsent.requestInfoUpdate()
+        .then(() => AdsConsent.loadAndShowConsentFormIfRequired())
+        .catch(() => undefined);
+    }
+
+    const install = await (options.installInfoProvider
+      ?? new ReactNativeInstallInfoProvider(options.installTimeProvider)).get().catch(() => ({} as import('./installInfo.js').InstallInfo));
+    const screen = Dimensions.get('screen');
+    const platform = Platform.OS === 'ios' ? 'ios' : 'android';
+    const fetchPort = options.fetch ?? reactNativeFetch;
+
+    await this.instance.init({
+      baseUrl,
+      apiKey,
+      appId,
+      adapter,
+      platform,
+      storage: options.storage ?? new AsyncStorageAdapter(),
+      fetch: fetchPort,
+      transport: options.transport ?? createReactNativeTransport(baseUrl, apiKey),
+      installReferrer: options.installReferrer ?? install.installReferrer,
+      installBeginTimestampSeconds: options.installBeginTimestampSeconds ?? install.installBeginTimestampSeconds,
+      installTimeProvider: options.installTimeProvider
+        ?? (install.installTimeMs === undefined ? undefined : () => install.installTimeMs),
+      deepLink: options.deepLink ?? install.deepLink,
+      ...(options.override ? { override: options.override } : {}),
+      fallbackConfig: options.fallback ?? fallbackConfig,
+      context: {
+        locale: Intl.DateTimeFormat().resolvedOptions().locale,
+        timezone: Intl.DateTimeFormat().resolvedOptions().timeZone,
+        screen_width: Math.round(screen.width * screen.scale),
+        screen_height: Math.round(screen.height * screen.scale),
+        ...(options.appVersion ? { app_version: options.appVersion } : {}),
+        ...(options.deviceModel ? { device_model: options.deviceModel } : {}),
+        ...(options.advertisingId ? { advertising_id: options.advertisingId } : {}),
+        ...(options.context ?? {}),
+      },
+      debug: options.debug === true,
+    });
+
+    this.lifecycle = new AppStateLifecycle(this.instance);
+    this.lifecycle.start();
+    this.readyState.done = true;
+    this.readyState.resolve();
+    if (options.preload !== false) void this.instance.startAdPreload().catch(() => undefined);
+  }
+
+  static showInterstitial(screen?: string): Promise<InterstitialShowResult> { return this.instance.showInterstitial(screen); }
+  static showRewarded(screen?: string): Promise<RewardedResult> { return this.instance.showRewarded(screen); }
+  static gateUnlock(screen?: string): Promise<GateResult> { return this.instance.showGate(screen); }
+  static bannerFor(screen: string, slot = 'banner'): Promise<AdHandle | null> { return this.instance.bannerFor(screen, slot); }
+  static showBootAd(): Promise<BootAdResult> { return this.instance.loadAndShowBootAd(); }
+  static onAppBackground(): Promise<void> { return this.instance.onBackground(); }
+  static onAppForeground(): Promise<boolean> { return this.instance.onForeground(); }
+  static onBackground(): Promise<void> { return this.onAppBackground(); }
+  static onForeground(): Promise<boolean> { return this.onAppForeground(); }
+  static refresh(): Promise<void> { return this.instance.refresh(); }
+  static setSegmentOverride(slug: string): Promise<boolean> { return this.instance.setSegmentOverride(slug); }
+  static identify(userId: string, traits?: Record<string, unknown>): Promise<void> { return this.instance.identify(userId, traits); }
+  static track(name: string, props?: Record<string, unknown>): Promise<void> { return this.instance.track(name, props); }
+
+  static dispose(): void {
+    this.lifecycle?.stop();
+    this.lifecycle = null;
+    this.instance.dispose();
+    this.gmaAdapter = null;
+    this.resetReady();
+  }
+
+  /** Uso interno do componente Banner para mapear falha real do componente para o fallback do core. */
+  static nativeAdapter(): ReactNativeGmaAdapter | null { return this.gmaAdapter; }
+}

package/src/index.ts

@@ -0,0 +1,8 @@
+export { ReactNativeGmaAdapter } from './adapter.js';
+export { AsyncStorageAdapter } from './storage.js';
+export { reactNativeFetch, createReactNativeTransport } from './transport.js';
+export { AppStateLifecycle, type LifecycleTarget } from './lifecycle.js';
+export { ReactNativeInstallInfoProvider, type InstallInfo, type InstallInfoProvider } from './installInfo.js';
+export { GabagoolAds, type GabagoolInitOptions } from './facade.js';
+export { Banner, type BannerProps } from './Banner.js';
+export * from '@gabagool-sdk/core';

package/src/installInfo.ts

@@ -0,0 +1,43 @@
+import { Linking, Platform } from 'react-native';
+import { PlayInstallReferrer } from 'react-native-play-install-referrer';
+
+export interface InstallInfo {
+  installReferrer?: string;
+  installBeginTimestampSeconds?: number;
+  installTimeMs?: number;
+  deepLink?: string;
+}
+
+export interface InstallInfoProvider { get(): Promise<InstallInfo>; }
+
+/** Provider injetável nos testes/iOS; falhas do módulo nativo viram campos ausentes. */
+export class ReactNativeInstallInfoProvider implements InstallInfoProvider {
+  constructor(private readonly installTimeProvider?: () => Promise<number | null | undefined> | number | null | undefined) {}
+
+  async get(): Promise<InstallInfo> {
+    const deepLink = await Linking.getInitialURL().catch(() => null);
+    const installTimeMs = await Promise.resolve(this.installTimeProvider?.()).catch(() => null);
+    const referrer = Platform.OS === 'android' ? await this.readReferrer() : {};
+    return {
+      ...referrer,
+      ...(typeof installTimeMs === 'number' && installTimeMs > 0 ? { installTimeMs } : {}),
+      ...(deepLink ? { deepLink } : {}),
+    };
+  }
+
+  private readReferrer(): Promise<Pick<InstallInfo, 'installReferrer' | 'installBeginTimestampSeconds'>> {
+    return new Promise((resolve) => {
+      try {
+        PlayInstallReferrer.getInstallReferrerInfo((info, error) => {
+          if (error || !info) return resolve({});
+          resolve({
+            ...(info.installReferrer ? { installReferrer: info.installReferrer } : {}),
+            ...(info.installBeginTimestampSeconds > 0
+              ? { installBeginTimestampSeconds: info.installBeginTimestampSeconds }
+              : {}),
+          });
+        });
+      } catch { resolve({}); }
+    });
+  }
+}

package/src/lifecycle.ts

@@ -0,0 +1,35 @@
+import { AppState, type AppStateStatus, type NativeEventSubscription } from 'react-native';
+
+export interface LifecycleTarget {
+  onBackground(): Promise<void>;
+  onForeground(): Promise<boolean>;
+}
+
+/** Traduz AppState para o lifecycle puro do core e serializa callbacks. */
+export class AppStateLifecycle {
+  private state: AppStateStatus = AppState.currentState;
+  private subscription: NativeEventSubscription | null = null;
+  private pending: Promise<unknown> = Promise.resolve();
+
+  constructor(private readonly target: LifecycleTarget) {}
+
+  start(): void {
+    if (this.subscription) return;
+    this.subscription = AppState.addEventListener('change', this.onChange);
+  }
+
+  stop(): void {
+    this.subscription?.remove();
+    this.subscription = null;
+  }
+
+  private readonly onChange = (next: AppStateStatus): void => {
+    const previous = this.state;
+    this.state = next;
+    if (previous === 'active' && next !== 'active') {
+      this.pending = this.pending.then(() => this.target.onBackground()).catch(() => undefined);
+    } else if (previous !== 'active' && next === 'active') {
+      this.pending = this.pending.then(() => this.target.onForeground()).catch(() => undefined);
+    }
+  };
+}

package/src/storage.ts

@@ -0,0 +1,15 @@
+import AsyncStorage from '@react-native-async-storage/async-storage';
+import type { KVStorage } from '@gabagool-sdk/core';
+
+/** Porta KV concreta; o namespace `@gabagool/` continua sendo aplicado pelo core. */
+export class AsyncStorageAdapter implements KVStorage {
+  async get(key: string): Promise<string | null> {
+    try { return await AsyncStorage.getItem(key); } catch { return null; }
+  }
+  async set(key: string, value: string): Promise<void> {
+    try { await AsyncStorage.setItem(key, value); } catch { /* persistência nunca derruba o app */ }
+  }
+  async remove(key: string): Promise<void> {
+    try { await AsyncStorage.removeItem(key); } catch { /* persistência nunca derruba o app */ }
+  }
+}

package/src/transport.ts

@@ -0,0 +1,17 @@
+import { httpTransport, type FetchLike, type TelemetryTransport } from '@gabagool-sdk/core';
+
+function allowed(url: string): boolean {
+  try {
+    const u = new URL(url);
+    return u.protocol === 'https:' || (u.protocol === 'http:' && ['localhost', '127.0.0.1', '10.0.2.2'].includes(u.hostname));
+  } catch { return false; }
+}
+
+/** Fetch do React Native com a mesma restrição de transporte do porte Dart. */
+export const reactNativeFetch: FetchLike = async (url, init) => {
+  if (!allowed(url)) throw new Error('insecure_transport');
+  return fetch(url, init) as unknown as ReturnType<FetchLike>;
+};
+
+export const createReactNativeTransport = (baseUrl: string, apiKey: string): TelemetryTransport =>
+  httpTransport({ baseUrl, apiKey, fetch: reactNativeFetch });