react-native-daro 1.0.13 → 1.0.16

package/src/RewardedAd.ts

@@ -1,9 +1,9 @@
-import { NativeModules } from 'react-native';
 import {
   addEventListener,
   removeEventListener,
   AdEventEmitter,
 } from './EventEmitter';
+import NativeDaroModule from './NativeDaroModule';
 import type {
   AdDisplayFailedInfo,
   AdInfo,
@@ -16,8 +16,6 @@ import {
   type RewardedAdEventPayloadMap,
 } from './types/AdEvent';
 
-const { DaroMModule } = NativeModules;
-
 const {
   ON_REWARDED_AD_LOADED_EVENT,
   ON_REWARDED_AD_LOAD_FAILED_EVENT,
@@ -27,7 +25,7 @@ const {
   ON_REWARDED_AD_HIDDEN_EVENT,
   ON_REWARDED_AD_RECEIVED_REWARD_EVENT,
   ON_REWARDED_AD_IMPRESSION_RECORDED,
-} = DaroMModule.getConstants();
+} = NativeDaroModule.getConstants();
 
 const NATIVE_EVENT_BY_TYPE: Record<AdEventType | RewardedAdEventType, string> =
   {
@@ -42,24 +40,36 @@ const NATIVE_EVENT_BY_TYPE: Record<AdEventType | RewardedAdEventType, string> =
   };
 
 export class RewardedAd {
+  private static _nextRequestId = 1;
+  private static _legacyRequestIds = new Map<string, number>();
+  private static _legacyRequestIdSet = new Set<number>();
+
   private readonly eventEmitter = new AdEventEmitter();
 
-  private constructor(private readonly adUnitId: string) {}
+  private constructor(
+    private readonly requestId: number,
+    private readonly adUnitId: string
+  ) {}
 
   static createForAdRequest(adUnitId: string): RewardedAd {
-    return new RewardedAd(adUnitId);
+    const requestId = RewardedAd._nextRequestId++;
+    return new RewardedAd(requestId, adUnitId);
   }
 
   isAdReady(): Promise<boolean> {
-    return DaroMModule.isRewardedAdReady(this.adUnitId);
+    return NativeDaroModule.isRewardedAdReady(this.requestId, this.adUnitId);
   }
 
   load(): void {
-    DaroMModule.loadRewardedAd(this.adUnitId);
+    NativeDaroModule.loadRewardedAd(this.requestId, this.adUnitId);
   }
 
   show(customData?: string | null): void {
-    DaroMModule.showRewardedAd(this.adUnitId, customData ?? null);
+    NativeDaroModule.showRewardedAd(
+      this.requestId,
+      this.adUnitId,
+      customData ?? null
+    );
   }
 
   addAdEventListener<T extends AdEventType | RewardedAdEventType>(
@@ -67,9 +77,9 @@ export class RewardedAd {
     listener: (info: RewardedAdEventPayloadMap[T]) => void
   ): () => void {
     const nativeEvent = NATIVE_EVENT_BY_TYPE[type];
-    const adUnitId = this.adUnitId;
+    const requestId = this.requestId;
     return this.eventEmitter.addEventListener(nativeEvent, (payload: any) => {
-      if (payload?.adUnitId !== undefined && payload.adUnitId !== adUnitId) {
+      if (payload?.requestId !== requestId) {
         return;
       }
       listener(payload);
@@ -82,24 +92,49 @@ export class RewardedAd {
 
   // ---- Deprecated static API (backward compatibility) ----
 
+  private static _getLegacyRequestId(adUnitId: string): number {
+    let requestId = RewardedAd._legacyRequestIds.get(adUnitId);
+    if (requestId === undefined) {
+      requestId = RewardedAd._nextRequestId++;
+      RewardedAd._legacyRequestIds.set(adUnitId, requestId);
+      RewardedAd._legacyRequestIdSet.add(requestId);
+    }
+    return requestId;
+  }
+
+  private static _addLegacyEventListener<T>(
+    event: string,
+    listener: (info: T) => void
+  ): void {
+    addEventListener(event, (payload: any) => {
+      if (!RewardedAd._legacyRequestIdSet.has(payload?.requestId)) {
+        return;
+      }
+      listener(payload);
+    });
+  }
+
   /** @deprecated `RewardedAd.createForAdRequest(adUnitId)` 인스턴스의 `isAdReady()`를 사용하세요. */
   static isAdReady(adUnitId: string): Promise<boolean> {
-    return DaroMModule.isRewardedAdReady(adUnitId);
+    const requestId = RewardedAd._getLegacyRequestId(adUnitId);
+    return NativeDaroModule.isRewardedAdReady(requestId, adUnitId);
   }
 
   /** @deprecated `RewardedAd.createForAdRequest(adUnitId)` 인스턴스의 `load()`를 사용하세요. */
   static loadAd(adUnitId: string): void {
-    DaroMModule.loadRewardedAd(adUnitId);
+    const requestId = RewardedAd._getLegacyRequestId(adUnitId);
+    NativeDaroModule.loadRewardedAd(requestId, adUnitId);
   }
 
   /** @deprecated `RewardedAd.createForAdRequest(adUnitId)` 인스턴스의 `show()`를 사용하세요. */
   static showAd(adUnitId: string, customData?: string | null): void {
-    DaroMModule.showRewardedAd(adUnitId, customData ?? null);
+    const requestId = RewardedAd._getLegacyRequestId(adUnitId);
+    NativeDaroModule.showRewardedAd(requestId, adUnitId, customData ?? null);
   }
 
   /** @deprecated `addAdEventListener(AdEventType.LOADED, ...)`를 인스턴스에서 사용하세요. */
   static addAdLoadedEventListener(listener: (adInfo: AdInfo) => void): void {
-    addEventListener(ON_REWARDED_AD_LOADED_EVENT, listener);
+    RewardedAd._addLegacyEventListener(ON_REWARDED_AD_LOADED_EVENT, listener);
   }
 
   /** @deprecated 인스턴스의 `addAdEventListener` disposer를 사용하세요. */
@@ -111,7 +146,10 @@ export class RewardedAd {
   static addAdLoadFailedEventListener(
     listener: (errorInfo: AdLoadFailedInfo) => void
   ): void {
-    addEventListener(ON_REWARDED_AD_LOAD_FAILED_EVENT, listener);
+    RewardedAd._addLegacyEventListener(
+      ON_REWARDED_AD_LOAD_FAILED_EVENT,
+      listener
+    );
   }
 
   /** @deprecated 인스턴스의 `addAdEventListener` disposer를 사용하세요. */
@@ -121,7 +159,7 @@ export class RewardedAd {
 
   /** @deprecated `addAdEventListener(AdEventType.CLICKED, ...)`를 인스턴스에서 사용하세요. */
   static addAdClickedEventListener(listener: (adInfo: AdInfo) => void): void {
-    addEventListener(ON_REWARDED_AD_CLICKED_EVENT, listener);
+    RewardedAd._addLegacyEventListener(ON_REWARDED_AD_CLICKED_EVENT, listener);
   }
 
   /** @deprecated 인스턴스의 `addAdEventListener` disposer를 사용하세요. */
@@ -131,7 +169,10 @@ export class RewardedAd {
 
   /** @deprecated `addAdEventListener(AdEventType.DISPLAYED, ...)`를 인스턴스에서 사용하세요. */
   static addAdDisplayedEventListener(listener: (adInfo: AdInfo) => void): void {
-    addEventListener(ON_REWARDED_AD_DISPLAYED_EVENT, listener);
+    RewardedAd._addLegacyEventListener(
+      ON_REWARDED_AD_DISPLAYED_EVENT,
+      listener
+    );
   }
 
   /** @deprecated 인스턴스의 `addAdEventListener` disposer를 사용하세요. */
@@ -143,7 +184,10 @@ export class RewardedAd {
   static addAdFailedToDisplayEventListener(
     listener: (errorInfo: AdDisplayFailedInfo) => void
   ): void {
-    addEventListener(ON_REWARDED_AD_FAILED_TO_DISPLAY_EVENT, listener);
+    RewardedAd._addLegacyEventListener(
+      ON_REWARDED_AD_FAILED_TO_DISPLAY_EVENT,
+      listener
+    );
   }
 
   /** @deprecated 인스턴스의 `addAdEventListener` disposer를 사용하세요. */
@@ -153,7 +197,7 @@ export class RewardedAd {
 
   /** @deprecated `addAdEventListener(AdEventType.HIDDEN, ...)`를 인스턴스에서 사용하세요. */
   static addAdHiddenEventListener(listener: (adInfo: AdInfo) => void): void {
-    addEventListener(ON_REWARDED_AD_HIDDEN_EVENT, listener);
+    RewardedAd._addLegacyEventListener(ON_REWARDED_AD_HIDDEN_EVENT, listener);
   }
 
   /** @deprecated 인스턴스의 `addAdEventListener` disposer를 사용하세요. */
@@ -165,7 +209,10 @@ export class RewardedAd {
   static addAdImpressionRecordedListener(
     listener: (adInfo: AdInfo) => void
   ): void {
-    addEventListener(ON_REWARDED_AD_IMPRESSION_RECORDED, listener);
+    RewardedAd._addLegacyEventListener(
+      ON_REWARDED_AD_IMPRESSION_RECORDED,
+      listener
+    );
   }
 
   /** @deprecated 인스턴스의 `addAdEventListener` disposer를 사용하세요. */
@@ -177,7 +224,10 @@ export class RewardedAd {
   static addAdReceivedRewardEventListener(
     listener: (adInfo: AdRewardInfo) => void
   ): void {
-    addEventListener(ON_REWARDED_AD_RECEIVED_REWARD_EVENT, listener);
+    RewardedAd._addLegacyEventListener(
+      ON_REWARDED_AD_RECEIVED_REWARD_EVENT,
+      listener
+    );
   }
 
   /** @deprecated 인스턴스의 `addAdEventListener` disposer를 사용하세요. */

package/src/codegen-env.d.ts

@@ -0,0 +1,45 @@
+declare module 'react-native/Libraries/Types/CodegenTypes' {
+  import type { NativeSyntheticEvent } from 'react-native';
+
+  export type DirectEventHandler<
+    T,
+    PaperName extends string | never = never,
+  > = [PaperName] extends [never]
+    ? (event: NativeSyntheticEvent<T>) => void | Promise<void>
+    : (event: NativeSyntheticEvent<T>) => void | Promise<void>;
+  export type Int32 = number;
+  export type Double = number;
+  export type UnsafeObject = object;
+  export type UnsafeMixed = unknown;
+  export type WithDefault<Type, Value> = Type | (Value & never);
+}
+
+declare module 'react-native/Libraries/Utilities/codegenNativeCommands' {
+  export interface Options<T extends string> {
+    readonly supportedCommands: ReadonlyArray<T>;
+  }
+
+  function codegenNativeCommands<T extends object>(
+    options: Options<keyof T extends string ? keyof T : never>
+  ): T;
+
+  export default codegenNativeCommands;
+}
+
+declare module 'react-native/Libraries/Utilities/codegenNativeComponent' {
+  import type { HostComponent } from 'react-native';
+
+  export interface Options {
+    readonly interfaceOnly?: boolean | undefined;
+    readonly paperComponentName?: string | undefined;
+    readonly paperComponentNameDeprecated?: string | undefined;
+    readonly excludedPlatforms?: ReadonlyArray<'iOS' | 'android'> | undefined;
+  }
+
+  function codegenNativeComponent<Props extends object>(
+    componentName: string,
+    options?: Options
+  ): HostComponent<Props>;
+
+  export default codegenNativeComponent;
+}

package/src/hooks/useInterstitialAd.ts

@@ -0,0 +1,117 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { InterstitialAd } from '../InterstitialAd';
+import { AdEventType } from '../types/AdEvent';
+import type {
+  AdDisplayFailedInfo,
+  AdInfo,
+  AdLoadFailedInfo,
+} from '../types/AdInfo';
+
+export type UseInterstitialAdOptions = {
+  onLoaded?: (adInfo: AdInfo) => void;
+  onLoadFailed?: (error: AdLoadFailedInfo) => void;
+  onClicked?: (adInfo: AdInfo) => void;
+  onDisplayed?: (adInfo: AdInfo) => void;
+  onFailedToDisplay?: (error: AdDisplayFailedInfo) => void;
+  onHidden?: (adInfo: AdInfo) => void;
+  onImpressionRecorded?: (adInfo: AdInfo) => void;
+};
+
+export type UseInterstitialAdResult = {
+  isLoaded: boolean;
+  isLoading: boolean;
+  load: () => void;
+  show: () => void;
+  isAdReady: () => Promise<boolean>;
+};
+
+export function useInterstitialAd(
+  adUnitId: string | null,
+  options: UseInterstitialAdOptions = {}
+): UseInterstitialAdResult {
+  const adRef = useRef<InterstitialAd | null>(null);
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+  const [state, setState] = useState({
+    isLoaded: false,
+    isLoading: false,
+  });
+
+  const load = useCallback(() => {
+    if (!adUnitId) {
+      return;
+    }
+
+    const ad = adRef.current;
+    if (!ad) {
+      return;
+    }
+
+    setState({ isLoaded: false, isLoading: true });
+    ad.load();
+  }, [adUnitId]);
+
+  const show = useCallback(() => {
+    adRef.current?.show();
+  }, []);
+
+  const isAdReady = useCallback(async () => {
+    const isLoaded = (await adRef.current?.isAdReady()) ?? false;
+    setState((prevState) => ({ ...prevState, isLoaded }));
+    return isLoaded;
+  }, []);
+
+  useEffect(() => {
+    adRef.current?.removeAllListeners();
+    adRef.current = null;
+    setState({ isLoaded: false, isLoading: false });
+
+    if (!adUnitId) {
+      return;
+    }
+
+    const ad = InterstitialAd.createForAdRequest(adUnitId);
+    adRef.current = ad;
+
+    ad.addAdEventListener(AdEventType.LOADED, (info) => {
+      setState({ isLoaded: true, isLoading: false });
+      optionsRef.current.onLoaded?.(info);
+    });
+    ad.addAdEventListener(AdEventType.LOAD_FAILED, (error) => {
+      setState({ isLoaded: false, isLoading: false });
+      optionsRef.current.onLoadFailed?.(error);
+    });
+    ad.addAdEventListener(AdEventType.DISPLAYED, (info) => {
+      setState((prevState) => ({ ...prevState, isLoaded: false }));
+      optionsRef.current.onDisplayed?.(info);
+    });
+    ad.addAdEventListener(AdEventType.FAILED_TO_DISPLAY, (error) => {
+      setState({ isLoaded: false, isLoading: false });
+      optionsRef.current.onFailedToDisplay?.(error);
+    });
+    ad.addAdEventListener(AdEventType.HIDDEN, (info) => {
+      setState((prevState) => ({ ...prevState, isLoaded: false }));
+      optionsRef.current.onHidden?.(info);
+    });
+    ad.addAdEventListener(AdEventType.CLICKED, (info) => {
+      optionsRef.current.onClicked?.(info);
+    });
+    ad.addAdEventListener(AdEventType.IMPRESSION_RECORDED, (info) => {
+      optionsRef.current.onImpressionRecorded?.(info);
+    });
+
+    return () => {
+      ad.removeAllListeners();
+      if (adRef.current === ad) {
+        adRef.current = null;
+      }
+    };
+  }, [adUnitId]);
+
+  return {
+    ...state,
+    load,
+    show,
+    isAdReady,
+  };
+}

package/src/hooks/useLightPopupAd.ts

@@ -0,0 +1,132 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { LightPopupAd } from '../LightPopupAd';
+import { AdEventType } from '../types/AdEvent';
+import type {
+  AdDisplayFailedInfo,
+  AdInfo,
+  AdLoadFailedInfo,
+} from '../types/AdInfo';
+import type { LightPopupAdConfiguration } from '../types/LightPopupAd';
+
+export type UseLightPopupAdOptions = {
+  onLoaded?: (adInfo: AdInfo) => void;
+  onLoadFailed?: (error: AdLoadFailedInfo) => void;
+  onClicked?: (adInfo: AdInfo) => void;
+  onDisplayed?: (adInfo: AdInfo) => void;
+  onFailedToDisplay?: (error: AdDisplayFailedInfo) => void;
+  onHidden?: (adInfo: AdInfo) => void;
+  onImpressionRecorded?: (adInfo: AdInfo) => void;
+};
+
+export type UseLightPopupAdLoadOptions = {
+  configuration?: LightPopupAdConfiguration;
+};
+
+export type UseLightPopupAdResult = {
+  isLoaded: boolean;
+  isLoading: boolean;
+  load: (options?: UseLightPopupAdLoadOptions) => void;
+  show: () => void;
+  isAdReady: () => Promise<boolean>;
+};
+
+export function useLightPopupAd(
+  adUnitId: string | null,
+  options: UseLightPopupAdOptions = {}
+): UseLightPopupAdResult {
+  const adRef = useRef<LightPopupAd | null>(null);
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+  const [state, setState] = useState({
+    isLoaded: false,
+    isLoading: false,
+  });
+
+  const createAd = useCallback(() => {
+    if (!adUnitId) {
+      return null;
+    }
+
+    adRef.current?.removeAllListeners();
+
+    const ad = LightPopupAd.createForAdRequest(adUnitId);
+    adRef.current = ad;
+
+    ad.addAdEventListener(AdEventType.LOADED, (info) => {
+      setState({ isLoaded: true, isLoading: false });
+      optionsRef.current.onLoaded?.(info);
+    });
+    ad.addAdEventListener(AdEventType.LOAD_FAILED, (error) => {
+      setState({ isLoaded: false, isLoading: false });
+      optionsRef.current.onLoadFailed?.(error);
+    });
+    ad.addAdEventListener(AdEventType.DISPLAYED, (info) => {
+      setState((prevState) => ({ ...prevState, isLoaded: false }));
+      optionsRef.current.onDisplayed?.(info);
+    });
+    ad.addAdEventListener(AdEventType.FAILED_TO_DISPLAY, (error) => {
+      setState({ isLoaded: false, isLoading: false });
+      optionsRef.current.onFailedToDisplay?.(error);
+    });
+    ad.addAdEventListener(AdEventType.HIDDEN, (info) => {
+      setState((prevState) => ({ ...prevState, isLoaded: false }));
+      optionsRef.current.onHidden?.(info);
+    });
+    ad.addAdEventListener(AdEventType.CLICKED, (info) => {
+      optionsRef.current.onClicked?.(info);
+    });
+    ad.addAdEventListener(AdEventType.IMPRESSION_RECORDED, (info) => {
+      optionsRef.current.onImpressionRecorded?.(info);
+    });
+
+    return ad;
+  }, [adUnitId]);
+
+  const load = useCallback(
+    (loadOptions?: UseLightPopupAdLoadOptions) => {
+      const ad = createAd();
+      if (!ad) {
+        return;
+      }
+
+      setState({ isLoaded: false, isLoading: true });
+
+      if (loadOptions?.configuration) {
+        ad.setConfiguration(loadOptions.configuration);
+      }
+
+      ad.load();
+    },
+    [createAd]
+  );
+
+  const show = useCallback(() => {
+    adRef.current?.show();
+  }, []);
+
+  const isAdReady = useCallback(async () => {
+    const isLoaded = (await adRef.current?.isAdReady()) ?? false;
+    setState((prevState) => ({ ...prevState, isLoaded }));
+    return isLoaded;
+  }, []);
+
+  useEffect(() => {
+    adRef.current?.removeAllListeners();
+    adRef.current = null;
+    setState({ isLoaded: false, isLoading: false });
+  }, [adUnitId]);
+
+  useEffect(() => {
+    return () => {
+      adRef.current?.removeAllListeners();
+      adRef.current = null;
+    };
+  }, []);
+
+  return {
+    ...state,
+    load,
+    show,
+    isAdReady,
+  };
+}

package/src/hooks/useRewardedAd.ts

@@ -0,0 +1,122 @@
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { RewardedAd } from '../RewardedAd';
+import { AdEventType, RewardedAdEventType } from '../types/AdEvent';
+import type {
+  AdDisplayFailedInfo,
+  AdInfo,
+  AdLoadFailedInfo,
+  AdRewardInfo,
+} from '../types/AdInfo';
+
+export type UseRewardedAdOptions = {
+  onLoaded?: (adInfo: AdInfo) => void;
+  onLoadFailed?: (error: AdLoadFailedInfo) => void;
+  onClicked?: (adInfo: AdInfo) => void;
+  onDisplayed?: (adInfo: AdInfo) => void;
+  onFailedToDisplay?: (error: AdDisplayFailedInfo) => void;
+  onHidden?: (adInfo: AdInfo) => void;
+  onImpressionRecorded?: (adInfo: AdInfo) => void;
+  onReceivedReward?: (reward: AdRewardInfo) => void;
+};
+
+export type UseRewardedAdResult = {
+  isLoaded: boolean;
+  isLoading: boolean;
+  load: () => void;
+  show: (customData?: string | null) => void;
+  isAdReady: () => Promise<boolean>;
+};
+
+export function useRewardedAd(
+  adUnitId: string | null,
+  options: UseRewardedAdOptions = {}
+): UseRewardedAdResult {
+  const adRef = useRef<RewardedAd | null>(null);
+  const optionsRef = useRef(options);
+  optionsRef.current = options;
+  const [state, setState] = useState({
+    isLoaded: false,
+    isLoading: false,
+  });
+
+  const load = useCallback(() => {
+    if (!adUnitId) {
+      return;
+    }
+
+    const ad = adRef.current;
+    if (!ad) {
+      return;
+    }
+
+    setState({ isLoaded: false, isLoading: true });
+    ad.load();
+  }, [adUnitId]);
+
+  const show = useCallback((customData?: string | null) => {
+    adRef.current?.show(customData);
+  }, []);
+
+  const isAdReady = useCallback(async () => {
+    const isLoaded = (await adRef.current?.isAdReady()) ?? false;
+    setState((prevState) => ({ ...prevState, isLoaded }));
+    return isLoaded;
+  }, []);
+
+  useEffect(() => {
+    adRef.current?.removeAllListeners();
+    adRef.current = null;
+    setState({ isLoaded: false, isLoading: false });
+
+    if (!adUnitId) {
+      return;
+    }
+
+    const ad = RewardedAd.createForAdRequest(adUnitId);
+    adRef.current = ad;
+
+    ad.addAdEventListener(AdEventType.LOADED, (info) => {
+      setState({ isLoaded: true, isLoading: false });
+      optionsRef.current.onLoaded?.(info);
+    });
+    ad.addAdEventListener(AdEventType.LOAD_FAILED, (error) => {
+      setState({ isLoaded: false, isLoading: false });
+      optionsRef.current.onLoadFailed?.(error);
+    });
+    ad.addAdEventListener(AdEventType.DISPLAYED, (info) => {
+      setState((prevState) => ({ ...prevState, isLoaded: false }));
+      optionsRef.current.onDisplayed?.(info);
+    });
+    ad.addAdEventListener(AdEventType.FAILED_TO_DISPLAY, (error) => {
+      setState({ isLoaded: false, isLoading: false });
+      optionsRef.current.onFailedToDisplay?.(error);
+    });
+    ad.addAdEventListener(AdEventType.HIDDEN, (info) => {
+      setState((prevState) => ({ ...prevState, isLoaded: false }));
+      optionsRef.current.onHidden?.(info);
+    });
+    ad.addAdEventListener(AdEventType.CLICKED, (info) => {
+      optionsRef.current.onClicked?.(info);
+    });
+    ad.addAdEventListener(AdEventType.IMPRESSION_RECORDED, (info) => {
+      optionsRef.current.onImpressionRecorded?.(info);
+    });
+    ad.addAdEventListener(RewardedAdEventType.RECEIVED_REWARD, (reward) => {
+      optionsRef.current.onReceivedReward?.(reward);
+    });
+
+    return () => {
+      ad.removeAllListeners();
+      if (adRef.current === ad) {
+        adRef.current = null;
+      }
+    };
+  }, [adUnitId]);
+
+  return {
+    ...state,
+    load,
+    show,
+    isAdReady,
+  };
+}

package/src/index.tsx

@@ -1,10 +1,26 @@
-import { NativeModules, Platform } from 'react-native';
+import NativeDaroModule from './NativeDaroModule';
 
 export * from './AdBannerView';
 export * from './types';
 export { InterstitialAd } from './InterstitialAd';
+export { useInterstitialAd } from './hooks/useInterstitialAd';
+export type {
+  UseInterstitialAdOptions,
+  UseInterstitialAdResult,
+} from './hooks/useInterstitialAd';
 export { RewardedAd } from './RewardedAd';
+export { useRewardedAd } from './hooks/useRewardedAd';
+export type {
+  UseRewardedAdOptions,
+  UseRewardedAdResult,
+} from './hooks/useRewardedAd';
 export { LightPopupAd } from './LightPopupAd';
+export { useLightPopupAd } from './hooks/useLightPopupAd';
+export type {
+  UseLightPopupAdOptions,
+  UseLightPopupAdLoadOptions,
+  UseLightPopupAdResult,
+} from './hooks/useLightPopupAd';
 
 export { NativeAdView } from './nativeAd/NativeAdView';
 export {
@@ -15,31 +31,14 @@ export {
   TitleView,
 } from './nativeAd/NativeAdViewComponents';
 
-const LINKING_ERROR =
-  `The package 'react-native-daro-m' doesn't seem to be linked. 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 Go\n';
-
-const DaroMModule = NativeModules.DaroMModule
-  ? NativeModules.DaroMModule
-  : new Proxy(
-      {},
-      {
-        get() {
-          throw new Error(LINKING_ERROR);
-        },
-      }
-    );
-
 export async function initialize() {
-  await DaroMModule.initializeSdk();
+  await NativeDaroModule.initializeSdk();
 }
 
 export async function showMediationDebugger() {
-  await DaroMModule.showMediationDebugger();
+  await NativeDaroModule.showMediationDebugger();
 }
 
-export async function setUserId(userId: String) {
-  await DaroMModule.setUserId(userId);
+export async function setUserId(userId: string) {
+  await NativeDaroModule.setUserId(userId);
 }