@apps-in-toss/native-modules 0.0.0-dev.1752049503789

package/dist/index.cjs

@@ -0,0 +1,775 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var index_exports = {};
+__export(index_exports, {
+  Accuracy: () => Accuracy2,
+  AppsInTossModule: () => AppsInTossModule,
+  BedrockCoreModule: () => BedrockCoreModule,
+  BedrockModule: () => BedrockModule,
+  GoogleAdMob: () => GoogleAdMob,
+  INTERNAL__AppsInTossModule: () => AppsInTossModuleInstance,
+  INTERNAL__module: () => INTERNAL__module,
+  Storage: () => Storage,
+  TossPay: () => TossPay,
+  appLogin: () => appLogin,
+  appsInTossEvent: () => appsInTossEvent,
+  closeView: () => closeView,
+  eventLog: () => eventLog,
+  fetchAlbumPhotos: () => fetchAlbumPhotos,
+  fetchContacts: () => fetchContacts,
+  generateHapticFeedback: () => generateHapticFeedback,
+  getClipboardText: () => getClipboardText,
+  getCurrentLocation: () => getCurrentLocation,
+  getDeviceId: () => getDeviceId,
+  getLocale: () => getLocale,
+  getNetworkStatus: () => getNetworkStatus,
+  getOperationalEnvironment: () => getOperationalEnvironment,
+  getPlatformOS: () => getPlatformOS,
+  getSchemeUri: () => getSchemeUri,
+  getTossAppVersion: () => getTossAppVersion,
+  getTossShareLink: () => getTossShareLink,
+  isMinVersionSupported: () => isMinVersionSupported,
+  openCamera: () => openCamera,
+  openURL: () => openURL,
+  saveBase64Data: () => saveBase64Data,
+  setClipboardText: () => setClipboardText,
+  setDeviceOrientation: () => setDeviceOrientation,
+  setIosSwipeGestureEnabled: () => setIosSwipeGestureEnabled,
+  setScreenAwakeMode: () => setScreenAwakeMode,
+  setSecureScreen: () => setSecureScreen,
+  share: () => share,
+  startUpdateLocation: () => startUpdateLocation
+});
+module.exports = __toCommonJS(index_exports);
+
+// src/AppsInTossModule/native-event-emitter/appsInTossEvent.ts
+var import_react_native6 = require("@granite-js/react-native");
+
+// src/AppsInTossModule/native-event-emitter/event-plugins/EntryMessageExitedEvent.ts
+var import_react_native = require("@granite-js/react-native");
+var EntryMessageExitedEvent = class extends import_react_native.GraniteEventDefinition {
+  name = "entryMessageExited";
+  remove() {
+  }
+  // eslint-disable-next-line @typescript-eslint/no-unused-vars
+  listener(_) {
+  }
+};
+
+// src/AppsInTossModule/native-event-emitter/event-plugins/UpdateLocationEvent.ts
+var import_react_native4 = require("@granite-js/react-native");
+
+// src/AppsInTossModule/native-modules/AppsInTossModule.ts
+var import_react_native2 = require("react-native");
+var Module = import_react_native2.TurboModuleRegistry.getEnforcing("AppsInTossModule");
+var AppsInTossModuleInstance = Module;
+var AppsInTossModule = Module;
+
+// src/AppsInTossModule/native-modules/getPermission.ts
+function getPermission(permission) {
+  return AppsInTossModule.getPermission(permission);
+}
+
+// src/AppsInTossModule/native-modules/openPermissionDialog.ts
+function openPermissionDialog(permission) {
+  return AppsInTossModule.openPermissionDialog(permission);
+}
+
+// src/AppsInTossModule/native-modules/requestPermission.ts
+async function requestPermission(permission) {
+  const permissionStatus = await getPermission(permission);
+  switch (permissionStatus) {
+    case "allowed":
+    case "denied":
+      return permissionStatus;
+    default:
+      return openPermissionDialog(permission);
+  }
+}
+
+// src/AppsInTossModule/native-event-emitter/nativeEventEmitter.ts
+var import_react_native3 = require("react-native");
+var nativeEventEmitter = new import_react_native3.NativeEventEmitter(AppsInTossModuleInstance);
+
+// src/AppsInTossModule/native-event-emitter/event-plugins/UpdateLocationEvent.ts
+var UpdateLocationEvent = class extends import_react_native4.GraniteEventDefinition {
+  name = "updateLocationEvent";
+  subscriptionCount = 0;
+  ref = {
+    remove: () => {
+    }
+  };
+  remove() {
+    if (--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/AppsInTossModule/native-event-emitter/internal/AppBridgeCallbackEvent.ts
+var import_react_native5 = require("@granite-js/react-native");
+
+// 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/AppsInTossModule/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 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 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/AppsInTossModule/native-event-emitter/internal/AppBridgeCallbackEvent.ts
+var UNSAFE__nativeEventEmitter = nativeEventEmitter;
+var AppBridgeCallbackEvent = class _AppBridgeCallbackEvent extends import_react_native5.GraniteEventDefinition {
+  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/AppsInTossModule/native-event-emitter/appsInTossEvent.ts
+var appsInTossEvent = new import_react_native6.GraniteEvent([
+  new AppBridgeCallbackEvent(),
+  new UpdateLocationEvent(),
+  new EntryMessageExitedEvent()
+]);
+
+// src/AppsInTossModule/native-event-emitter/startUpdateLocation.ts
+function startUpdateLocation(eventParams) {
+  return appsInTossEvent.addEventListener("updateLocationEvent", eventParams);
+}
+
+// src/AppsInTossModule/native-modules/ads/googleAdMob.ts
+var import_es_toolkit = require("es-toolkit");
+
+// src/AppsInTossModule/native-modules/getOperationalEnvironment.ts
+function getOperationalEnvironment() {
+  return AppsInTossModule.operationalEnvironment;
+}
+
+// src/AppsInTossModule/native-modules/isMinVersionSupported.ts
+var import_react_native7 = require("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/AppsInTossModule/native-modules/isMinVersionSupported.ts
+function isMinVersionSupported(minVersions) {
+  const operationalEnvironment = AppsInTossModule.operationalEnvironment;
+  if (operationalEnvironment === "sandbox") {
+    return true;
+  }
+  const currentVersion = AppsInTossModule.tossAppVersion;
+  const isIOS = import_react_native7.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/AppsInTossModule/native-modules/ads/googleAdMob.ts
+function loadAdMobInterstitialAd(params) {
+  if (!loadAdMobInterstitialAd.isSupported()) {
+    params.onError(new Error(UNSUPPORTED_ERROR_MESSAGE));
+    return import_es_toolkit.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 import_es_toolkit.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 import_es_toolkit.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 import_es_toolkit.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") {
+      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/AppsInTossModule/native-modules/checkoutPayment.ts
+async function checkoutPayment(options) {
+  return AppsInTossModule.checkoutPayment({ params: options });
+}
+
+// src/AppsInTossModule/native-modules/setClipboardText.ts
+async function setClipboardText(text) {
+  const permissionStatus = await requestPermission({ name: "clipboard", access: "write" });
+  if (permissionStatus === "denied") {
+    throw new Error("\uD074\uB9BD\uBCF4\uB4DC \uC4F0\uAE30 \uAD8C\uD55C\uC774 \uAC70\uBD80\uB418\uC5C8\uC5B4\uC694.");
+  }
+  return AppsInTossModule.setClipboardText({ text });
+}
+
+// src/AppsInTossModule/native-modules/getClipboardText.ts
+async function getClipboardText() {
+  const permissionStatus = await requestPermission({ name: "clipboard", access: "read" });
+  if (permissionStatus === "denied") {
+    throw new Error("\uD074\uB9BD\uBCF4\uB4DC \uC77D\uAE30 \uAD8C\uD55C\uC774 \uAC70\uBD80\uB418\uC5C8\uC5B4\uC694.");
+  }
+  return AppsInTossModule.getClipboardText({});
+}
+
+// src/AppsInTossModule/native-modules/fetchContacts.ts
+async function fetchContacts(options) {
+  const permissionStatus = await requestPermission({ name: "contacts", access: "read" });
+  if (permissionStatus === "denied") {
+    throw new Error("\uC5F0\uB77D\uCC98 \uAD8C\uD55C\uC774 \uAC70\uBD80\uB418\uC5C8\uC5B4\uC694.");
+  }
+  const contacts = await AppsInTossModule.fetchContacts(options);
+  return {
+    result: contacts.result,
+    nextOffset: contacts.nextOffset ?? null,
+    done: contacts.done
+  };
+}
+
+// src/AppsInTossModule/native-modules/fetchAlbumPhotos.ts
+var DEFAULT_MAX_COUNT = 10;
+var DEFAULT_MAX_WIDTH = 1024;
+async function fetchAlbumPhotos(options) {
+  const permissionStatus = await requestPermission({ name: "photos", access: "read" });
+  if (permissionStatus === "denied") {
+    throw new Error("\uC0AC\uC9C4\uCCA9 \uAD8C\uD55C\uC774 \uAC70\uBD80\uB418\uC5C8\uC5B4\uC694.");
+  }
+  const albumPhotos = await AppsInTossModule.fetchAlbumPhotos({
+    ...options,
+    maxCount: options.maxCount ?? DEFAULT_MAX_COUNT,
+    maxWidth: options.maxWidth ?? DEFAULT_MAX_WIDTH
+  });
+  return albumPhotos;
+}
+
+// src/AppsInTossModule/native-modules/getCurrentLocation.ts
+async function getCurrentLocation(options) {
+  const permissionStatus = await requestPermission({ name: "geolocation", access: "access" });
+  if (permissionStatus === "denied") {
+    throw new Error("\uC704\uCE58 \uAD8C\uD55C\uC774 \uAC70\uBD80\uB418\uC5C8\uC5B4\uC694.");
+  }
+  const position = await AppsInTossModule.getCurrentLocation(options);
+  return position;
+}
+
+// src/AppsInTossModule/native-modules/openCamera.ts
+async function openCamera(options) {
+  const permissionStatus = await requestPermission({ name: "camera", access: "access" });
+  if (permissionStatus === "denied") {
+    throw new Error("\uCE74\uBA54\uB77C \uAD8C\uD55C\uC774 \uAC70\uBD80\uB418\uC5C8\uC5B4\uC694.");
+  }
+  const photo = await AppsInTossModule.openCamera({ base64: false, maxWidth: 1024, ...options });
+  return photo;
+}
+
+// src/AppsInTossModule/native-modules/appLogin.ts
+async function appLogin() {
+  return AppsInTossModule.appLogin({});
+}
+
+// src/AppsInTossModule/native-modules/getTossAppVersion.ts
+function getTossAppVersion() {
+  return AppsInTossModule.tossAppVersion;
+}
+
+// src/AppsInTossModule/native-modules/getDeviceId.ts
+function getDeviceId() {
+  return AppsInTossModule.deviceId;
+}
+
+// src/AppsInTossModule/native-modules/storage.ts
+function getItem(key) {
+  return AppsInTossModule.getStorageItem({ key });
+}
+function setItem(key, value) {
+  return AppsInTossModule.setStorageItem({
+    key,
+    value
+  });
+}
+function removeItem(key) {
+  return AppsInTossModule.removeStorageItem({ key });
+}
+function clearItems() {
+  return AppsInTossModule.clearStorage({});
+}
+var Storage = {
+  getItem,
+  setItem,
+  removeItem,
+  clearItems
+};
+
+// src/AppsInTossModule/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/AppsInTossModule/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/AppsInTossModule/native-modules/setDeviceOrientation.ts
+async function setDeviceOrientation(options) {
+  const isSupported = isMinVersionSupported({
+    android: "5.215.0",
+    ios: "5.215.0"
+  });
+  if (!isSupported) {
+    return;
+  }
+  return AppsInTossModule.setDeviceOrientation(options);
+}
+
+// src/AppsInTossModule/native-modules/saveBase64Data.ts
+async function saveBase64Data(params) {
+  const isSupported = isMinVersionSupported({
+    android: "5.218.0",
+    ios: "5.216.0"
+  });
+  if (!isSupported) {
+    console.warn("saveBase64Data is not supported in this app version");
+    return;
+  }
+  await AppsInTossModule.saveBase64Data(params);
+}
+
+// src/AppsInTossModule/native-modules/index.ts
+var TossPay = {
+  checkoutPayment
+};
+var GoogleAdMob = {
+  loadAdMobInterstitialAd,
+  showAdMobInterstitialAd,
+  loadAdMobRewardedAd,
+  showAdMobRewardedAd
+};
+
+// src/BedrockModule/native-modules/natives/BedrockModule.ts
+var import_react_native8 = require("react-native");
+var BedrockModule = import_react_native8.NativeModules.BedrockModule;
+
+// src/BedrockModule/native-modules/natives/closeView.ts
+async function closeView() {
+  return BedrockModule.closeView();
+}
+
+// src/BedrockModule/native-modules/natives/getLocale.ts
+var import_react_native9 = require("react-native");
+function getLocale() {
+  const locale = BedrockModule?.DeviceInfo?.locale ?? "ko-KR";
+  if (import_react_native9.Platform.OS === "android") {
+    return replaceUnderbarToHypen(locale);
+  }
+  return locale;
+}
+function replaceUnderbarToHypen(locale) {
+  return locale.replace(/_/g, "-");
+}
+
+// src/BedrockModule/native-modules/natives/getSchemeUri.ts
+function getSchemeUri() {
+  return BedrockModule.schemeUri;
+}
+
+// src/BedrockModule/native-modules/natives/generateHapticFeedback/index.ts
+function generateHapticFeedback(options) {
+  return BedrockModule.generateHapticFeedback(options);
+}
+
+// src/BedrockModule/native-modules/natives/share.ts
+async function share(message) {
+  BedrockModule.share(message);
+}
+
+// src/BedrockModule/native-modules/natives/setSecureScreen.ts
+function setSecureScreen(options) {
+  return BedrockModule.setSecureScreen(options);
+}
+
+// src/BedrockModule/native-modules/natives/setScreenAwakeMode.ts
+async function setScreenAwakeMode(options) {
+  return BedrockModule.setScreenAwakeMode(options);
+}
+
+// src/BedrockModule/native-modules/natives/getNetworkStatus/index.ts
+function getNetworkStatus() {
+  return BedrockModule.getNetworkStatus();
+}
+
+// src/BedrockModule/native-modules/natives/setIosSwipeGestureEnabled.ts
+async function setIosSwipeGestureEnabled(options) {
+  if (BedrockModule.setIosSwipeGestureEnabled == null) {
+    return;
+  }
+  return BedrockModule.setIosSwipeGestureEnabled(options);
+}
+
+// src/BedrockModule/native-modules/natives/openURL.ts
+var import_react_native10 = require("react-native");
+function openURL(url) {
+  return import_react_native10.Linking.openURL(url);
+}
+
+// src/BedrockModule/native-modules/natives/getPlatformOS.ts
+var import_react_native11 = require("react-native");
+function getPlatformOS() {
+  return import_react_native11.Platform.OS;
+}
+
+// src/BedrockModule/native-modules/core/BedrockCoreModule.ts
+var import_react_native12 = require("react-native");
+var BedrockCoreModule = import_react_native12.NativeModules.BedrockCoreModule;
+
+// src/types.ts
+var Accuracy2 = /* @__PURE__ */ ((Accuracy3) => {
+  Accuracy3[Accuracy3["Lowest"] = 1] = "Lowest";
+  Accuracy3[Accuracy3["Low"] = 2] = "Low";
+  Accuracy3[Accuracy3["Balanced"] = 3] = "Balanced";
+  Accuracy3[Accuracy3["High"] = 4] = "High";
+  Accuracy3[Accuracy3["Highest"] = 5] = "Highest";
+  Accuracy3[Accuracy3["BestForNavigation"] = 6] = "BestForNavigation";
+  return Accuracy3;
+})(Accuracy2 || {});
+
+// src/AppsInTossModule/native-modules/tossCore.ts
+var import_react_native13 = require("react-native");
+var TossCoreModule = import_react_native13.NativeModules.TossCoreModule;
+function tossCoreEventLog(params) {
+  const supported = isMinVersionSupported({ ios: "5.210.0", android: "5.210.0" });
+  const isSandbox = getOperationalEnvironment() === "sandbox";
+  if (!supported || isSandbox) {
+    return;
+  }
+  TossCoreModule.eventLog({
+    params: {
+      log_name: params.log_name,
+      log_type: params.log_type,
+      params: params.params
+    }
+  });
+}
+
+// src/index.ts
+var INTERNAL__module = {
+  tossCoreEventLog
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Accuracy,
+  AppsInTossModule,
+  BedrockCoreModule,
+  BedrockModule,
+  GoogleAdMob,
+  INTERNAL__AppsInTossModule,
+  INTERNAL__module,
+  Storage,
+  TossPay,
+  appLogin,
+  appsInTossEvent,
+  closeView,
+  eventLog,
+  fetchAlbumPhotos,
+  fetchContacts,
+  generateHapticFeedback,
+  getClipboardText,
+  getCurrentLocation,
+  getDeviceId,
+  getLocale,
+  getNetworkStatus,
+  getOperationalEnvironment,
+  getPlatformOS,
+  getSchemeUri,
+  getTossAppVersion,
+  getTossShareLink,
+  isMinVersionSupported,
+  openCamera,
+  openURL,
+  saveBase64Data,
+  setClipboardText,
+  setDeviceOrientation,
+  setIosSwipeGestureEnabled,
+  setScreenAwakeMode,
+  setSecureScreen,
+  share,
+  startUpdateLocation
+});