@apps-in-toss/framework 0.0.21 → 0.0.23

package/dist/index.js

@@ -8,77 +8,275 @@ var __export = (target, all) => {
 import { TDSProvider } from "@toss-design-system/react-native";
 import { Bedrock } from "react-native-bedrock";
 
-// src/core/hooks/useAppsInTossBridge.ts
-import { useBridge } from "@toss-design-system/react-native";
+// src/core/components/AppEvent.tsx
 import { useEffect } from "react";
+import { getSchemeUri as getSchemeUri2 } from "react-native-bedrock";
 
-// src/core/utils/getAppsInTossGlobals.ts
-function getAppsInTossGlobals() {
-  if (global.__appsInToss == null) {
-    throw new Error("invalid apps-in-toss globals");
-  }
-  return global.__appsInToss;
+// ../../.yarn/cache/es-toolkit-npm-1.34.1-4cd6371dcb-aab6d07be3.zip/node_modules/es-toolkit/dist/function/noop.mjs
+function noop() {
 }
 
-// src/core/utils/toIcon.ts
-function toIcon(source) {
-  return source.startsWith("http") ? { source: { uri: source } } : { name: source };
-}
+// src/native-modules/AppsInTossModule.ts
+import { NativeModules } from "react-native";
+var AppsInTossModuleInstance = NativeModules.AppsInTossModule;
+var AppsInTossModule = AppsInTossModuleInstance;
 
-// src/core/hooks/useAppsInTossBridge.ts
-function useAppsInTossBridge() {
-  const controller = useBridge();
-  const appsInTossGlobals2 = getAppsInTossGlobals();
-  useEffect(() => {
-    const commonProps = {
-      serviceName: appsInTossGlobals2.brandDisplayName,
-      icon: toIcon(appsInTossGlobals2.brandIcon),
-      color: appsInTossGlobals2.brandPrimaryColor,
-      colorMode: appsInTossGlobals2.brandBridgeColorMode
-    };
-    controller.open({ ...commonProps });
-  }, []);
+// src/utils/generateUUID.ts
+function generateUUID(placeholder) {
+  return placeholder ? (placeholder ^ Math.random() * 16 >> placeholder / 4).toString(16) : (String(1e7) + 1e3 + 4e3 + 8e3 + 1e11).replace(/[018]/g, generateUUID);
 }
 
-// src/core/registerApp.tsx
-import { Fragment, jsx } from "react/jsx-runtime";
-function AppsInTossContainer(Container, { children, ...initialProps }) {
-  return /* @__PURE__ */ jsx(Container, { ...initialProps, children: /* @__PURE__ */ jsx(TDSProvider, { colorPreference: "light", token: { color: { primary: getAppsInTossGlobals().brandPrimaryColor } }, children: /* @__PURE__ */ jsx(TDSContainer, { ...initialProps, children }) }) });
-}
-function TDSContainer({ children }) {
-  useAppsInTossBridge();
-  return /* @__PURE__ */ jsx(Fragment, { children });
+// src/native-event-emitter/internal/appBridge.ts
+var INTERNAL__callbacks = /* @__PURE__ */ new Map();
+function invokeAppBridgeCallback(id, ...args) {
+  const callback = INTERNAL__callbacks.get(id);
+  callback?.call(null, ...args);
+  return Boolean(callback);
 }
-function registerApp(container, { context }) {
-  return Bedrock.registerApp(AppsInTossContainer.bind(null, container), {
-    appName: getAppName(),
-    context
+function invokeAppBridgeMethod(methodName, params, callbacks) {
+  const { onSuccess, onError, ...appBridgeCallbacks } = callbacks;
+  const { callbackMap, unregisterAll } = registerCallbacks(appBridgeCallbacks);
+  const promise = AppsInTossModuleInstance[methodName]({
+    params,
+    callbacks: callbackMap
   });
+  void promise.then(onSuccess).catch(onError);
+  return unregisterAll;
 }
-function getAppName() {
-  try {
-    return global.__bedrock.app.name;
-  } catch (error) {
-    console.error("unexpected error occurred while getting app name");
-    throw error;
+function registerCallbacks(callbacks) {
+  const callbackMap = {};
+  for (const [callbackName, callback] of Object.entries(callbacks)) {
+    const id = registerCallback(callback, callbackName);
+    callbackMap[callbackName] = id;
   }
+  const unregisterAll = () => {
+    Object.values(callbackMap).forEach(unregisterCallback);
+  };
+  return { callbackMap, unregisterAll };
+}
+function registerCallback(callback, name = "unnamed") {
+  const uniqueId = generateUUID();
+  const callbackId = `${uniqueId}__${name}`;
+  INTERNAL__callbacks.set(callbackId, callback);
+  return callbackId;
 }
+function unregisterCallback(id) {
+  INTERNAL__callbacks.delete(id);
+}
+function getCallbackIds() {
+  return Array.from(INTERNAL__callbacks.keys());
+}
+var INTERNAL__appBridgeHandler = {
+  invokeAppBridgeCallback,
+  invokeAppBridgeMethod,
+  registerCallback,
+  unregisterCallback,
+  getCallbackIds
+};
 
-// src/core/index.ts
-var AppsInToss = {
-  registerApp
+// src/native-modules/getOperationalEnvironment.ts
+function getOperationalEnvironment() {
+  return AppsInTossModule.operationalEnvironment;
+}
+
+// src/native-modules/isMinVersionSupported.ts
+import { Platform } from "react-native";
+
+// src/utils/compareVersion.ts
+var SEMVER_REGEX = /^[v^~<>=]*?(\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+)(?:\.([x*]|\d+))?(?:-([\da-z\\-]+(?:\.[\da-z\\-]+)*))?(?:\+[\da-z\\-]+(?:\.[\da-z\\-]+)*)?)?)?$/i;
+var isWildcard = (val) => ["*", "x", "X"].includes(val);
+var tryParse = (val) => {
+  const num = parseInt(val, 10);
+  return isNaN(num) ? val : num;
+};
+var coerceTypes = (a, b) => {
+  return typeof a === typeof b ? [a, b] : [String(a), String(b)];
+};
+var compareValues = (a, b) => {
+  if (isWildcard(a) || isWildcard(b)) {
+    return 0;
+  }
+  const [aVal, bVal] = coerceTypes(tryParse(a), tryParse(b));
+  if (aVal > bVal) {
+    return 1;
+  }
+  if (aVal < bVal) {
+    return -1;
+  }
+  return 0;
+};
+var parseVersion = (version) => {
+  if (typeof version !== "string") {
+    throw new TypeError("Invalid argument: expected a string");
+  }
+  const match = version.match(SEMVER_REGEX);
+  if (!match) {
+    throw new Error(`Invalid semver: '${version}'`);
+  }
+  const [, major, minor, patch, build, preRelease] = match;
+  return [major, minor, patch, build, preRelease];
+};
+var compareSegments = (a, b) => {
+  const maxLength = Math.max(a.length, b.length);
+  for (let i = 0; i < maxLength; i++) {
+    const segA = a[i] ?? "0";
+    const segB = b[i] ?? "0";
+    const result = compareValues(segA, segB);
+    if (result !== 0) {
+      return result;
+    }
+  }
+  return 0;
+};
+var compareVersions = (v1, v2) => {
+  const seg1 = parseVersion(v1);
+  const seg2 = parseVersion(v2);
+  const preRelease1 = seg1.pop();
+  const preRelease2 = seg2.pop();
+  const mainCompare = compareSegments(seg1, seg2);
+  if (mainCompare !== 0) {
+    return mainCompare;
+  }
+  if (preRelease1 && preRelease2) {
+    return compareSegments(preRelease1.split("."), preRelease2.split("."));
+  }
+  if (preRelease1) {
+    return -1;
+  }
+  if (preRelease2) {
+    return 1;
+  }
+  return 0;
 };
 
-// src/native-event-emitter/bedrock-event.ts
-import { BedrockEvent } from "react-native-bedrock";
+// src/native-modules/isMinVersionSupported.ts
+function isMinVersionSupported(minVersions) {
+  const operationalEnvironment2 = AppsInTossModule.operationalEnvironment;
+  if (operationalEnvironment2 === "sandbox") {
+    return true;
+  }
+  const currentVersion = AppsInTossModule.tossAppVersion;
+  const isIOS = Platform.OS === "ios";
+  const minVersion = isIOS ? minVersions.ios : minVersions.android;
+  if (minVersion === void 0) {
+    return false;
+  }
+  if (minVersion === "always") {
+    return true;
+  }
+  if (minVersion === "never") {
+    return false;
+  }
+  return compareVersions(currentVersion, minVersion) >= 0;
+}
 
-// src/native-event-emitter/event-plugins/UpdateLocationEvent.ts
-import { BedrockEventDefinition } from "react-native-bedrock";
+// src/native-modules/ads/googleAdMob.ts
+function loadAdMobInterstitialAd(params) {
+  if (!loadAdMobInterstitialAd.isSupported()) {
+    params.onError(new Error(UNSUPPORTED_ERROR_MESSAGE));
+    return noop;
+  }
+  const { onEvent, onError, options } = params;
+  const unregisterCallbacks = INTERNAL__appBridgeHandler.invokeAppBridgeMethod("loadAdMobInterstitialAd", options, {
+    onAdClicked: () => {
+      onEvent({ type: "clicked" });
+    },
+    onAdDismissed: () => {
+      onEvent({ type: "dismissed" });
+    },
+    onAdFailedToShow: () => {
+      onEvent({ type: "failedToShow" });
+    },
+    onAdImpression: () => {
+      onEvent({ type: "impression" });
+    },
+    onAdShow: () => {
+      onEvent({ type: "show" });
+    },
+    onSuccess: (result) => onEvent({ type: "loaded", data: result }),
+    onError
+  });
+  return unregisterCallbacks;
+}
+function showAdMobInterstitialAd(params) {
+  if (!showAdMobInterstitialAd.isSupported()) {
+    params.onError(new Error(UNSUPPORTED_ERROR_MESSAGE));
+    return noop;
+  }
+  const { onEvent, onError, options } = params;
+  const unregisterCallbacks = INTERNAL__appBridgeHandler.invokeAppBridgeMethod("showAdMobInterstitialAd", options, {
+    onSuccess: () => onEvent({ type: "requested" }),
+    onError
+  });
+  return unregisterCallbacks;
+}
+function loadAdMobRewardedAd(params) {
+  if (!loadAdMobRewardedAd.isSupported()) {
+    params.onError(new Error(UNSUPPORTED_ERROR_MESSAGE));
+    return noop;
+  }
+  const { onEvent, onError, options } = params;
+  const unregisterCallbacks = INTERNAL__appBridgeHandler.invokeAppBridgeMethod("loadAdMobRewardedAd", options, {
+    onAdClicked: () => {
+      onEvent({ type: "clicked" });
+    },
+    onAdDismissed: () => {
+      onEvent({ type: "dismissed" });
+    },
+    onAdFailedToShow: () => {
+      onEvent({ type: "failedToShow" });
+    },
+    onAdImpression: () => {
+      onEvent({ type: "impression" });
+    },
+    onAdShow: () => {
+      onEvent({ type: "show" });
+    },
+    onUserEarnedReward: () => {
+      onEvent({ type: "userEarnedReward" });
+    },
+    onSuccess: (result) => onEvent({ type: "loaded", data: result }),
+    onError
+  });
+  return unregisterCallbacks;
+}
+function showAdMobRewardedAd(params) {
+  if (!showAdMobRewardedAd.isSupported()) {
+    params.onError(new Error(UNSUPPORTED_ERROR_MESSAGE));
+    return noop;
+  }
+  const { onEvent, onError, options } = params;
+  const unregisterCallbacks = INTERNAL__appBridgeHandler.invokeAppBridgeMethod("showAdMobRewardedAd", options, {
+    onSuccess: () => onEvent({ type: "requested" }),
+    onError
+  });
+  return unregisterCallbacks;
+}
+var ANDROID_GOOGLE_AD_MOB_SUPPORTED_VERSION = "5.209.0";
+var IOS_GOOGLE_AD_MOB_SUPPORTED_VERSION = "5.209.0";
+var UNSUPPORTED_ERROR_MESSAGE = "This feature is not supported in the current environment";
+var ENVIRONMENT = getOperationalEnvironment();
+function createIsSupported() {
+  return () => {
+    if (ENVIRONMENT !== "toss") {
+      console.warn("Google AdMob is not supported in the current environment");
+      return false;
+    }
+    return isMinVersionSupported({
+      android: ANDROID_GOOGLE_AD_MOB_SUPPORTED_VERSION,
+      ios: IOS_GOOGLE_AD_MOB_SUPPORTED_VERSION
+    });
+  };
+}
+loadAdMobInterstitialAd.isSupported = createIsSupported();
+loadAdMobRewardedAd.isSupported = createIsSupported();
+showAdMobInterstitialAd.isSupported = createIsSupported();
+showAdMobRewardedAd.isSupported = createIsSupported();
 
-// src/native-modules/AppsInTossModule.ts
-import { NativeModules } from "react-native";
-var AppsInTossModuleInstance = NativeModules.AppsInTossModule;
-var AppsInTossModule = AppsInTossModuleInstance;
+// src/native-modules/checkoutPayment.ts
+async function checkoutPayment(options) {
+  return AppsInTossModule.checkoutPayment({ params: options });
+}
 
 // src/native-modules/getPermission.ts
 function getPermission(permission) {
@@ -102,56 +300,6 @@ async function requestPermission(permission) {
   }
 }
 
-// src/native-event-emitter/nativeEventEmitter.ts
-import { NativeEventEmitter } from "react-native";
-var nativeEventEmitter = new NativeEventEmitter(AppsInTossModuleInstance);
-
-// src/native-event-emitter/event-plugins/UpdateLocationEvent.ts
-var UpdateLocationEvent = class extends BedrockEventDefinition {
-  name = "updateLocationEvent";
-  subscriptionCount = 0;
-  ref = {
-    remove: () => {
-    }
-  };
-  remove() {
-    --this.subscriptionCount === 0 && AppsInTossModuleInstance.stopUpdateLocation({});
-    this.ref.remove();
-  }
-  listener(options, onEvent, onError) {
-    requestPermission({ name: "geolocation", access: "access" }).then((permissionStatus) => {
-      if (permissionStatus === "denied") {
-        onError(new Error("\uC704\uCE58 \uAD8C\uD55C\uC774 \uAC70\uBD80\uB418\uC5C8\uC5B4\uC694."));
-        return;
-      }
-      void AppsInTossModuleInstance.startUpdateLocation(options).catch(onError);
-      const subscription = nativeEventEmitter.addListener("updateLocation", onEvent);
-      this.ref = {
-        remove: () => subscription?.remove()
-      };
-      this.subscriptionCount++;
-    }).catch(onError);
-  }
-};
-
-// src/native-event-emitter/bedrock-event.ts
-var appsInTossEvent = new BedrockEvent([new UpdateLocationEvent()]);
-
-// src/native-event-emitter/startUpdateLocation.ts
-function startUpdateLocation(eventParams) {
-  return appsInTossEvent.addEventListener("updateLocationEvent", eventParams);
-}
-
-// src/native-modules/checkoutPayment.ts
-async function checkoutPayment(options) {
-  return AppsInTossModule.checkoutPayment(options);
-}
-
-// src/native-modules/executePayment.ts
-async function executePayment(options) {
-  return AppsInTossModule.executePayment(options);
-}
-
 // src/native-modules/setClipboardText.ts
 async function setClipboardText(text) {
   const permissionStatus = await requestPermission({ name: "clipboard", access: "write" });
@@ -233,11 +381,6 @@ async function appLogin() {
   return AppsInTossModule.appLogin({});
 }
 
-// src/native-modules/getOperationalEnvironment.ts
-function getOperationalEnvironment() {
-  return AppsInTossModule.operationalEnvironment;
-}
-
 // src/native-modules/getTossAppVersion.ts
 function getTossAppVersion() {
   return AppsInTossModule.tossAppVersion;
@@ -271,10 +414,274 @@ var Storage = {
   clearItems
 };
 
+// src/native-modules/eventLog.ts
+function normalizeParams(params) {
+  return Object.fromEntries(
+    Object.entries(params).filter(([, value]) => value !== void 0).map(([key, value]) => [key, String(value)])
+  );
+}
+async function eventLog(params) {
+  if (AppsInTossModule.operationalEnvironment === "sandbox") {
+    console.log("[eventLogDebug]", {
+      log_name: params.log_name,
+      log_type: params.log_type,
+      params: normalizeParams(params.params)
+    });
+    return;
+  }
+  const isSupported = isMinVersionSupported({
+    android: "5.208.0",
+    ios: "5.208.0"
+  });
+  if (!isSupported) {
+    return;
+  }
+  return AppsInTossModule.eventLog({
+    log_name: params.log_name,
+    log_type: params.log_type,
+    params: normalizeParams(params.params)
+  });
+}
+
+// src/native-modules/getTossShareLink.ts
+async function getTossShareLink(path) {
+  const { shareLink } = await AppsInTossModule.getTossShareLink({});
+  const shareUrl = new URL(shareLink);
+  shareUrl.searchParams.set("deep_link_value", path);
+  shareUrl.searchParams.set("af_dp", path);
+  return shareUrl.toString();
+}
+
 // src/native-modules/index.ts
 var TossPay = {
-  checkoutPayment,
-  executePayment
+  checkoutPayment
+};
+var GoogleAdMob = {
+  loadAdMobInterstitialAd,
+  showAdMobInterstitialAd,
+  loadAdMobRewardedAd,
+  showAdMobRewardedAd
+};
+
+// src/native-event-emitter/appsInTossEvent.ts
+import { BedrockEvent } from "react-native-bedrock";
+
+// src/native-event-emitter/event-plugins/EntryMessageExitedEvent.ts
+import { BedrockEventDefinition } from "react-native-bedrock";
+var EntryMessageExitedEvent = class extends BedrockEventDefinition {
+  name = "entryMessageExited";
+  remove() {
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  listener(_) {
+  }
+};
+
+// src/native-event-emitter/event-plugins/UpdateLocationEvent.ts
+import { BedrockEventDefinition as BedrockEventDefinition2 } from "react-native-bedrock";
+
+// src/native-event-emitter/nativeEventEmitter.ts
+import { NativeEventEmitter } from "react-native";
+var nativeEventEmitter = new NativeEventEmitter(AppsInTossModuleInstance);
+
+// src/native-event-emitter/event-plugins/UpdateLocationEvent.ts
+var UpdateLocationEvent = class extends BedrockEventDefinition2 {
+  name = "updateLocationEvent";
+  subscriptionCount = 0;
+  ref = {
+    remove: () => {
+    }
+  };
+  remove() {
+    --this.subscriptionCount === 0 && AppsInTossModuleInstance.stopUpdateLocation({});
+    this.ref.remove();
+  }
+  listener(options, onEvent, onError) {
+    requestPermission({ name: "geolocation", access: "access" }).then((permissionStatus) => {
+      if (permissionStatus === "denied") {
+        onError(new Error("\uC704\uCE58 \uAD8C\uD55C\uC774 \uAC70\uBD80\uB418\uC5C8\uC5B4\uC694."));
+        return;
+      }
+      void AppsInTossModuleInstance.startUpdateLocation(options).catch(onError);
+      const subscription = nativeEventEmitter.addListener("updateLocation", onEvent);
+      this.ref = {
+        remove: () => subscription?.remove()
+      };
+      this.subscriptionCount++;
+    }).catch(onError);
+  }
+};
+
+// src/native-event-emitter/internal/AppBridgeCallbackEvent.ts
+import { BedrockEventDefinition as BedrockEventDefinition3 } from "react-native-bedrock";
+var UNSAFE__nativeEventEmitter = nativeEventEmitter;
+var AppBridgeCallbackEvent = class _AppBridgeCallbackEvent extends BedrockEventDefinition3 {
+  static INTERNAL__appBridgeSubscription;
+  name = "appBridgeCallbackEvent";
+  constructor() {
+    super();
+    this.registerAppBridgeCallbackEventListener();
+  }
+  remove() {
+  }
+  listener() {
+  }
+  registerAppBridgeCallbackEventListener() {
+    if (_AppBridgeCallbackEvent.INTERNAL__appBridgeSubscription != null) {
+      return;
+    }
+    _AppBridgeCallbackEvent.INTERNAL__appBridgeSubscription = UNSAFE__nativeEventEmitter.addListener(
+      "appBridgeCallback",
+      this.ensureInvokeAppBridgeCallback
+    );
+  }
+  ensureInvokeAppBridgeCallback(result) {
+    if (typeof result === "object" && typeof result.name === "string") {
+      INTERNAL__appBridgeHandler.invokeAppBridgeCallback(result.name, result.params);
+    } else {
+      console.warn("Invalid app bridge callback result:", result);
+    }
+  }
+};
+
+// src/native-event-emitter/appsInTossEvent.ts
+var appsInTossEvent = new BedrockEvent([
+  new AppBridgeCallbackEvent(),
+  new UpdateLocationEvent(),
+  new EntryMessageExitedEvent()
+]);
+
+// src/native-event-emitter/startUpdateLocation.ts
+function startUpdateLocation(eventParams) {
+  return appsInTossEvent.addEventListener("updateLocationEvent", eventParams);
+}
+
+// src/env.ts
+var env = {
+  getDeploymentId: () => __DEV__ ? "local" : global.__appsInToss?.deploymentId
+};
+
+// src/core/hooks/useReferrer.ts
+import { useMemo } from "react";
+import { getSchemeUri } from "react-native-bedrock";
+function useReferrer() {
+  return useMemo(() => {
+    try {
+      return new URL(getSchemeUri()).searchParams.get("referrer");
+    } catch {
+      return null;
+    }
+  }, []);
+}
+
+// src/core/components/AppEvent.tsx
+var ENTRY_APP_EVENT_SCHEMA_ID = 1562181;
+function EntryAppEvent() {
+  const referrer = useReferrer() ?? "";
+  useEffect(() => {
+    eventLog({
+      log_name: "appsintoss_app_visit::impression__enter_appsintoss",
+      log_type: "info",
+      params: {
+        is_transform: true,
+        schema_id: ENTRY_APP_EVENT_SCHEMA_ID,
+        deployment_id: env.getDeploymentId(),
+        referrer
+      }
+    });
+  }, [referrer]);
+  return null;
+}
+function SystemAppEvent({ ...initialProps }) {
+  useEffect(() => {
+    eventLog({
+      log_name: "AppsInTossInitialProps",
+      log_type: "debug",
+      params: {
+        ...initialProps,
+        deployment_id: env.getDeploymentId(),
+        schemeUri: getSchemeUri2()
+      }
+    });
+  }, [initialProps]);
+  return null;
+}
+var AppEvent = {
+  Entry: EntryAppEvent,
+  System: SystemAppEvent
+};
+
+// src/core/hooks/useAppsInTossBridge.ts
+import { useBridge } from "@toss-design-system/react-native";
+import { useEffect as useEffect2 } from "react";
+
+// src/core/utils/getAppsInTossGlobals.ts
+function getAppsInTossGlobals() {
+  if (global.__appsInToss == null) {
+    throw new Error("invalid apps-in-toss globals");
+  }
+  return global.__appsInToss;
+}
+
+// src/core/utils/toIcon.ts
+function toIcon(source) {
+  return source.startsWith("http") ? { source: { uri: source } } : { name: source };
+}
+
+// src/core/hooks/useAppsInTossBridge.ts
+function useAppsInTossBridge() {
+  const controller = useBridge();
+  const appsInTossGlobals2 = getAppsInTossGlobals();
+  useEffect2(() => {
+    const commonProps = {
+      serviceName: appsInTossGlobals2.brandDisplayName,
+      icon: toIcon(appsInTossGlobals2.brandIcon),
+      color: appsInTossGlobals2.brandPrimaryColor,
+      colorMode: appsInTossGlobals2.brandBridgeColorMode
+    };
+    controller.open({
+      ...commonProps,
+      onExited: () => {
+        appsInTossEvent.emit("entryMessageExited", void 0);
+      }
+    });
+  }, []);
+}
+
+// src/core/registerApp.tsx
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+function AppsInTossContainer(Container, { children, ...initialProps }) {
+  return /* @__PURE__ */ jsxs(Fragment, { children: [
+    /* @__PURE__ */ jsx(AppEvent.Entry, {}),
+    /* @__PURE__ */ jsx(AppEvent.System, { ...initialProps }),
+    /* @__PURE__ */ jsx(Container, { ...initialProps, children: /* @__PURE__ */ jsx(TDSProvider, { colorPreference: "light", token: { color: { primary: getAppsInTossGlobals().brandPrimaryColor } }, children: /* @__PURE__ */ jsx(TDSContainer, { ...initialProps, children }) }) })
+  ] });
+}
+function TDSContainer({ children }) {
+  useAppsInTossBridge();
+  return /* @__PURE__ */ jsx(Fragment, { children });
+}
+function registerApp(container, { context }) {
+  return Bedrock.registerApp(AppsInTossContainer.bind(null, container), {
+    appName: getAppName(),
+    context,
+    defaultScreenOption: {
+      statusBarStyle: "dark"
+    }
+  });
+}
+function getAppName() {
+  try {
+    return global.__bedrock.app.name;
+  } catch (error) {
+    console.error("unexpected error occurred while getting app name");
+    throw error;
+  }
+}
+
+// src/core/index.ts
+var AppsInToss = {
+  registerApp
 };
 
 // src/components/WebView.tsx
@@ -283,8 +690,8 @@ import {
   ExternalWebViewScreen
 } from "@toss-design-system/react-native";
 import { useSafeAreaBottom, useSafeAreaTop as useSafeAreaTop2 } from "@toss-design-system/react-native/private";
-import { useMemo } from "react";
-import { getSchemeUri, useBridgeHandler, useBedrockEvent } from "react-native-bedrock";
+import { useMemo as useMemo3 } from "react";
+import { getSchemeUri as getSchemeUri3, useBedrockEvent } from "react-native-bedrock";
 import * as bedrockAsyncBridges from "react-native-bedrock/async-bridges";
 import * as bedrockConstantBridges from "react-native-bedrock/constant-bridges";
 
@@ -294,24 +701,24 @@ import {
 } from "@react-native-bedrock/native/react-native-webview";
 import { useDialog } from "@toss-design-system/react-native";
 import { josa } from "es-hangul";
-import { forwardRef, useCallback, useEffect as useEffect2 } from "react";
-import { BackHandler, Platform as Platform4, View as View3 } from "react-native";
+import { forwardRef, useCallback, useEffect as useEffect3 } from "react";
+import { BackHandler, Platform as Platform5, View as View3 } from "react-native";
 import { closeView, setIosSwipeGestureEnabled } from "react-native-bedrock";
 
 // src/components/GameWebViewNavigationBar/GameNavigationBar.tsx
 import { SvgXml } from "@react-native-bedrock/native/react-native-svg";
 import { PageNavbar } from "@toss-design-system/react-native";
-import { Platform as Platform3, TouchableOpacity, View as View2 } from "react-native";
+import { Platform as Platform4, TouchableOpacity, View as View2 } from "react-native";
 
 // src/components/GameWebViewNavigationBar/HeaderRight.tsx
 import { StyleSheet, View } from "react-native";
 
 // src/components/GameWebViewNavigationBar/byPlatform.ts
-import { Platform } from "react-native";
+import { Platform as Platform2 } from "react-native";
 function byPlatform({
   ...props
 }) {
-  return (props[Platform.OS] ?? props.fallback)();
+  return (props[Platform2.OS] ?? props.fallback)();
 }
 
 // src/components/GameWebViewNavigationBar/constants.ts
@@ -345,34 +752,34 @@ var styles = StyleSheet.create({
 
 // src/components/GameWebViewNavigationBar/useSafeAreaTop.ts
 import { useSafeAreaInsets } from "@react-native-bedrock/native/react-native-safe-area-context";
-import { Platform as Platform2 } from "react-native";
+import { Platform as Platform3 } from "react-native";
 function useSafeAreaTop() {
   const safeAreaInsets = useSafeAreaInsets();
-  const hasDynamicIsland = Platform2.OS === "ios" && safeAreaInsets.top > 50;
+  const hasDynamicIsland = Platform3.OS === "ios" && safeAreaInsets.top > 50;
   const safeAreaTop = hasDynamicIsland ? safeAreaInsets.top - 5 : safeAreaInsets.top;
   return safeAreaTop;
 }
 
 // src/components/GameWebViewNavigationBar/GameNavigationBar.tsx
-import { Fragment as Fragment2, jsx as jsx3, jsxs } from "react/jsx-runtime";
+import { Fragment as Fragment2, jsx as jsx3, jsxs as jsxs2 } from "react/jsx-runtime";
 var originXML = '<svg fill="none" height="30" viewBox="0 0 30 30" width="30" xmlns="https://www.w3.org/2000/svg"><rect fill="#031832" fill-opacity=".46" height="30" rx="15" width="30"/><rect height="29.5" rx="14.75" stroke="#d9d9ff" stroke-opacity=".11" stroke-width=".5" width="29.5" x=".25" y=".25"/><path clip-rule="evenodd" d="m16.5119 15.0014 4.7092-4.7092c.0929-.0928.1666-.2031.2169-.32441.0503-.12134.0762-.25141.0762-.38276.0001-.13136-.0258-.26144-.076-.38281s-.1239-.23166-.2167-.32457c-.0929-.09291-.2031-.16662-.3245-.21692-.1213-.05031-.2514-.07622-.3827-.07626-.1314-.00004-.2615.0258-.3828.07603-.1214.05023-.2317.12388-.3246.21673l-4.7092 4.70997-4.71-4.70997c-.1897-.17718-.4408-.27373-.70034-.26927s-.5072.10959-.69069.2932c-.1835.1836-.28848.43132-.29279.69087-.00432.25954.09238.51057.26968.70017l4.71004 4.7092-4.71004 4.7092c-.1392.1401-.23385.3183-.27204.5121-.0382.1939-.01823.3946.05739.5771s.20351.3386.36759.4486.35702.169.55456.1697c.25583 0 .51164-.0975.70664-.2925l4.71-4.71 4.7092 4.71c.0927.093.2029.1668.3243.2172.1213.0504.2514.0763.3828.0763s.2614-.0259.3828-.0763c.1213-.0504.2315-.1242.3243-.2172.0929-.0929.1667-.2032.217-.3246s.0762-.2515.0762-.3829-.0259-.2616-.0762-.383-.1241-.2317-.217-.3245z" fill="#fdfdfe" fill-opacity=".89" fill-rule="evenodd"/></svg>';
 function GameNavigationBar({ onClose }) {
   const safeAreaTop = useSafeAreaTop();
-  return /* @__PURE__ */ jsxs(Fragment2, { children: [
+  return /* @__PURE__ */ jsxs2(Fragment2, { children: [
     /* @__PURE__ */ jsx3(PageNavbar, { preference: { type: "none" } }),
     /* @__PURE__ */ jsx3(
       View2,
       {
         style: {
           width: "100%",
-          height: Platform3.OS === "ios" ? 44 : 54,
+          height: Platform4.OS === "ios" ? 44 : 54,
           flexDirection: "row",
           alignItems: "center",
           justifyContent: "flex-end",
           position: "absolute",
           zIndex: 9999,
           marginTop: safeAreaTop,
-          paddingRight: Platform3.OS === "ios" ? 10 : 8
+          paddingRight: Platform4.OS === "ios" ? 10 : 8
         },
         pointerEvents: "box-none",
         children: /* @__PURE__ */ jsx3(HeaderRight, { children: /* @__PURE__ */ jsx3(
@@ -383,7 +790,7 @@ function GameNavigationBar({ onClose }) {
             accessible: true,
             accessibilityLabel: "\uAC8C\uC784\uC885\uB8CC",
             style: {
-              padding: Platform3.OS === "ios" ? 7 : 9
+              padding: Platform4.OS === "ios" ? 7 : 9
             },
             onPress: onClose,
             children: /* @__PURE__ */ jsx3(SvgXml, { xml: originXML, width: 30, height: 30 })
@@ -395,7 +802,7 @@ function GameNavigationBar({ onClose }) {
 }
 
 // src/components/GameWebView.tsx
-import { Fragment as Fragment3, jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+import { Fragment as Fragment3, jsx as jsx4, jsxs as jsxs3 } from "react/jsx-runtime";
 var GameWebView = forwardRef(function GameWebView2(props, ref) {
   const { openConfirm } = useDialog();
   const { brandDisplayName } = getAppsInTossGlobals();
@@ -410,8 +817,8 @@ var GameWebView = forwardRef(function GameWebView2(props, ref) {
       closeView();
     }
   }, [brandDisplayName, openConfirm]);
-  useEffect2(() => {
-    if (Platform4.OS === "ios") {
+  useEffect3(() => {
+    if (Platform5.OS === "ios") {
       setIosSwipeGestureEnabled({ isEnabled: false });
       return () => {
         setIosSwipeGestureEnabled({ isEnabled: true });
@@ -419,7 +826,7 @@ var GameWebView = forwardRef(function GameWebView2(props, ref) {
     }
     return;
   }, []);
-  useEffect2(() => {
+  useEffect3(() => {
     const backHandler = () => {
       handleClose();
       return true;
@@ -429,7 +836,7 @@ var GameWebView = forwardRef(function GameWebView2(props, ref) {
       BackHandler.removeEventListener("hardwareBackPress", backHandler);
     };
   }, [handleClose]);
-  return /* @__PURE__ */ jsxs2(Fragment3, { children: [
+  return /* @__PURE__ */ jsxs3(Fragment3, { children: [
     /* @__PURE__ */ jsx4(GameNavigationBar, { onClose: handleClose }),
     /* @__PURE__ */ jsx4(View3, { style: { flex: 1 }, children: /* @__PURE__ */ jsx4(PlainWebView, { ref, ...props }) })
   ] });
@@ -440,15 +847,143 @@ var async_bridges_exports = {};
 __export(async_bridges_exports, {
   appLogin: () => appLogin,
   checkoutPayment: () => checkoutPayment,
-  executePayment: () => executePayment,
+  eventLog: () => eventLog,
   fetchAlbumPhotos: () => fetchAlbumPhotos,
   fetchContacts: () => fetchContacts,
   getClipboardText: () => getClipboardText,
   getCurrentLocation: () => getCurrentLocation,
+  getTossShareLink: () => getTossShareLink,
   openCamera: () => openCamera,
   setClipboardText: () => setClipboardText
 });
 
+// src/bridge-handler/useBridgeHandler.tsx
+import { useCallback as useCallback2, useMemo as useMemo2, useRef } from "react";
+function serializeError(error) {
+  return JSON.stringify(error, (_, value) => {
+    if (value instanceof Error) {
+      return {
+        name: value.name,
+        message: value.message,
+        stack: value.stack,
+        __isError: true
+      };
+    }
+    return value;
+  });
+}
+function methodHandler({
+  args,
+  eventId,
+  functionName,
+  handlerMap,
+  injectJavaScript
+}) {
+  const func = handlerMap[functionName];
+  if (!func) {
+    console.error(`${functionName} is not a function`);
+    return;
+  }
+  const wrappedFunc = async (...args2) => {
+    const result = await func(...args2);
+    return result;
+  };
+  wrappedFunc(...args).then((result) => {
+    injectJavaScript?.(`
+      window.__BEDROCK_NATIVE_EMITTER.emit('${functionName}/resolve/${eventId}', ${JSON.stringify(result, null, 0)});
+    `);
+  }).catch((error) => {
+    const serializedError = serializeError(error);
+    injectJavaScript?.(`
+      window.__BEDROCK_NATIVE_EMITTER.emit('${functionName}/reject/${eventId}', ${serializedError});
+    `);
+  });
+}
+var globalEventListenerMap = /* @__PURE__ */ new Map();
+function useBridgeHandler({
+  onMessage,
+  constantHandlerMap,
+  asyncHandlerMap,
+  eventListenerMap,
+  injectedJavaScript: originalInjectedJavaScript
+}) {
+  const ref = useRef(null);
+  const injectedJavaScript = useMemo2(
+    () => [
+      `window.__CONSTANT_HANDLER_MAP = ${JSON.stringify(
+        Object.entries(constantHandlerMap).reduce(
+          (acc, [key, value]) => {
+            acc[key] = typeof value === "function" ? value() : value;
+            return acc;
+          },
+          {}
+        )
+      )}`,
+      originalInjectedJavaScript,
+      "true"
+    ].join("\n"),
+    [constantHandlerMap, originalInjectedJavaScript]
+  );
+  const createHandleOnEvent = (functionName, eventId) => (response) => {
+    ref.current?.injectJavaScript(`
+      window.__BEDROCK_NATIVE_EMITTER.emit('${functionName}/onEvent/${eventId}', ${JSON.stringify(response, null, 0)});
+    `);
+  };
+  const createHandleOnError = (functionName, eventId) => (error) => {
+    ref.current?.injectJavaScript(`
+      window.__BEDROCK_NATIVE_EMITTER.emit('${functionName}/onError/${eventId}', ${JSON.stringify(error, null, 0)});
+    `);
+  };
+  const $onMessage = useCallback2(
+    async (e) => {
+      onMessage?.(e);
+      const data = JSON.parse(e.nativeEvent.data);
+      if (typeof data !== "object" || data === null || typeof data.functionName !== "string" || typeof data.eventId !== "string" || typeof data.type !== "string" || !["addEventListener", "removeEventListener", "method"].includes(data.type)) {
+        return;
+      }
+      switch (data.type) {
+        case "addEventListener": {
+          const handleOnEvent = createHandleOnEvent(data.functionName, data.eventId);
+          const handleOnError = createHandleOnError(data.functionName, data.eventId);
+          const remove = eventListenerMap[data.functionName]?.({
+            onEvent: handleOnEvent,
+            onError: handleOnError,
+            options: data.args
+          });
+          if (remove) {
+            globalEventListenerMap.set(`${data.functionName}/${data.eventId}`, remove);
+          }
+          break;
+        }
+        case "removeEventListener": {
+          const key = `${data.functionName}/${data.eventId}`;
+          const remove = globalEventListenerMap.get(key);
+          remove?.();
+          globalEventListenerMap.delete(key);
+          break;
+        }
+        case "method": {
+          methodHandler({
+            args: data.args,
+            eventId: data.eventId,
+            functionName: data.functionName,
+            handlerMap: asyncHandlerMap,
+            injectJavaScript: ref.current?.injectJavaScript
+          });
+          break;
+        }
+      }
+    },
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+    [onMessage]
+  );
+  return {
+    ref,
+    injectedJavaScript,
+    onMessage: $onMessage
+  };
+}
+
 // src/constant-bridges.ts
 var constant_bridges_exports = {};
 __export(constant_bridges_exports, {
@@ -457,11 +992,6 @@ __export(constant_bridges_exports, {
   getTossAppVersion: () => getTossAppVersion
 });
 
-// src/env.ts
-var env = {
-  getDeploymentId: () => __DEV__ ? "local" : global.__appsInToss?.deploymentId
-};
-
 // src/event-bridges.ts
 var event_bridges_exports = {};
 __export(event_bridges_exports, {
@@ -471,6 +1001,7 @@ __export(event_bridges_exports, {
 // src/components/WebView.tsx
 import { jsx as jsx5 } from "react/jsx-runtime";
 var appsInTossGlobals = getAppsInTossGlobals();
+var operationalEnvironment = getOperationalEnvironment();
 var TYPES = ["partner", "external", "game"];
 var WEBVIEW_TYPES = {
   partner: PartnerWebViewScreen,
@@ -479,7 +1010,7 @@ var WEBVIEW_TYPES = {
 };
 function mergeSchemeQueryParamsInto(url) {
   const baseUrl = new URL(url);
-  const schemeUrl = new URL(getSchemeUri());
+  const schemeUrl = new URL(getSchemeUri3());
   baseUrl.pathname = schemeUrl.pathname;
   for (const [key, value] of schemeUrl.searchParams.entries()) {
     baseUrl.searchParams.set(key, value);
@@ -504,7 +1035,7 @@ function WebView({ type, local, onMessage, ...props }) {
     throw new Error(`Invalid WebView type: '${type}'`);
   }
   const bedrockEvent = useBedrockEvent();
-  const uri = useMemo(() => getWebViewUri(local), [local]);
+  const uri = useMemo3(() => getWebViewUri(local), [local]);
   const top = useSafeAreaTop2();
   const bottom = useSafeAreaBottom();
   const handler = useBridgeHandler({
@@ -512,7 +1043,16 @@ function WebView({ type, local, onMessage, ...props }) {
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     eventListenerMap: {
       ...event_bridges_exports,
-      backEvent: ({ onEvent, onError, options }) => bedrockEvent.addEventListener("backEvent", { onEvent, onError, options })
+      backEvent: ({ onEvent, onError, options }) => bedrockEvent.addEventListener("backEvent", { onEvent, onError, options }),
+      entryMessageExited: ({ onEvent, onError }) => appsInTossEvent.addEventListener("entryMessageExited", { onEvent, onError }),
+      updateLocationEvent: ({ onEvent, onError, options }) => appsInTossEvent.addEventListener("updateLocationEvent", { onEvent, onError, options }),
+      /** @internal */
+      appBridgeCallbackEvent: ({ onEvent, onError, options }) => appsInTossEvent.addEventListener("appBridgeCallbackEvent", { onEvent, onError, options }),
+      /** AdMob */
+      loadAdMobInterstitialAd: GoogleAdMob.loadAdMobInterstitialAd,
+      showAdMobInterstitialAd: GoogleAdMob.showAdMobInterstitialAd,
+      loadAdMobRewardedAd: GoogleAdMob.loadAdMobRewardedAd,
+      showAdMobRewardedAd: GoogleAdMob.showAdMobRewardedAd
     },
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-expect-error
@@ -520,7 +1060,12 @@ function WebView({ type, local, onMessage, ...props }) {
       ...bedrockConstantBridges,
       ...constant_bridges_exports,
       getSafeAreaTop: () => top,
-      getSafeAreaBottom: () => bottom
+      getSafeAreaBottom: () => bottom,
+      /** AdMob */
+      loadAdMobInterstitialAd_isSupported: GoogleAdMob.loadAdMobInterstitialAd.isSupported,
+      showAdMobInterstitialAd_isSupported: GoogleAdMob.showAdMobInterstitialAd.isSupported,
+      loadAdMobRewardedAd_isSupported: GoogleAdMob.loadAdMobRewardedAd.isSupported,
+      showAdMobRewardedAd_isSupported: GoogleAdMob.showAdMobRewardedAd.isSupported
     },
     // eslint-disable-next-line @typescript-eslint/ban-ts-comment
     // @ts-expect-error
@@ -536,7 +1081,7 @@ function WebView({ type, local, onMessage, ...props }) {
       clearItems: Storage.clearItems
     }
   });
-  const baseProps = useMemo(() => {
+  const baseProps = useMemo3(() => {
     switch (type) {
       case "partner": {
         const headerOnlyProp = {
@@ -566,10 +1111,7 @@ function WebView({ type, local, onMessage, ...props }) {
     }
   }, [type, props]);
   const BaseWebView = WEBVIEW_TYPES[type];
-  const webviewDebuggingEnabled = useMemo(
-    () => getOperationalEnvironment() === "sandbox",
-    []
-  );
+  const webViewDebuggingEnabled = operationalEnvironment === "sandbox";
   return /* @__PURE__ */ jsx5(
     BaseWebView,
     {
@@ -578,7 +1120,7 @@ function WebView({ type, local, onMessage, ...props }) {
       ...baseProps,
       source: { uri },
       sharedCookiesEnabled: true,
-      webviewDebuggingEnabled,
+      webviewDebuggingEnabled: webViewDebuggingEnabled,
       thirdPartyCookiesEnabled: true,
       onMessage: handler.onMessage,
       injectedJavaScript: handler.injectedJavaScript,
@@ -594,12 +1136,12 @@ function ensureValue(value, name) {
 }
 
 // src/hooks/useGeolocation.ts
-import { useState, useEffect as useEffect3 } from "react";
+import { useState, useEffect as useEffect4 } from "react";
 import { useVisibility } from "react-native-bedrock";
 function useGeolocation({ accuracy, distanceInterval, timeInterval }) {
   const isVisible = useVisibility();
   const [location, setLocation] = useState(null);
-  useEffect3(() => {
+  useEffect4(() => {
     if (!isVisible) {
       return;
     }
@@ -629,11 +1171,14 @@ var Accuracy2 = /* @__PURE__ */ ((Accuracy3) => {
 export {
   Accuracy2 as Accuracy,
   AppsInToss,
+  GoogleAdMob,
   Storage,
   TossPay,
   WebView,
   appLogin,
+  appsInTossEvent,
   env,
+  eventLog,
   fetchAlbumPhotos,
   fetchContacts,
   getClipboardText,
@@ -641,6 +1186,8 @@ export {
   getDeviceId,
   getOperationalEnvironment,
   getTossAppVersion,
+  getTossShareLink,
+  isMinVersionSupported,
   openCamera,
   setClipboardText,
   startUpdateLocation,