{"version":3,"file":"TrackingTransparency-DunpgkgS.mjs","names":["NativeModulesProxy","isAsyncDebugging: boolean","ReactNativePlatform","Platform","Platform","response: Permission","ExpoTrackingTransparency"],"sources":["../../../node_modules/expo-modules-core/src/NativeModulesProxy.ts","../../../node_modules/expo-modules-core/src/TurboModuleToExpoModuleProxy.ts","../../../node_modules/expo-modules-core/src/ensureNativeModulesAreInstalled.ts","../../../node_modules/expo-modules-core/src/requireNativeModule.ts","../../../node_modules/expo-modules-core/src/environment/browser.ts","../../../node_modules/expo-modules-core/src/Platform.ts","../../../node_modules/expo-modules-core/src/errors/CodedError.ts","../../../node_modules/expo-modules-core/src/errors/UnavailabilityError.ts","../../../node_modules/expo-modules-core/src/PermissionsInterface.ts","../../../node_modules/expo-modules-core/src/PermissionsHook.ts","../../../node_modules/expo-tracking-transparency/build/ExpoTrackingTransparency.js","../../../node_modules/expo-tracking-transparency/build/TrackingTransparency.js"],"sourcesContent":["import type { ProxyNativeModule } from './NativeModulesProxy.types';\n\n// We default to an empty object shim wherever we don't have an environment-specific implementation\n\n/**\n * @deprecated `NativeModulesProxy` is deprecated and might be removed in the future releases.\n * Use `requireNativeModule` or `requireOptionalNativeModule` instead.\n */\nexport default {} as Record<string, ProxyNativeModule>;\n","// Copyright © 2024 650 Industries.\nimport type { TurboModule } from 'react-native';\n\nexport function createTurboModuleToExpoProxy(turboModule: TurboModule | null, name: string) {\n  return null;\n}\n","// Installs the expo global on web\nimport './polyfill';\n\n/**\n * Ensures that the native modules are installed in the current runtime.\n * Otherwise, it synchronously calls a native function that installs them.\n */\nexport function ensureNativeModulesAreInstalled(): void {\n  // No-op on web\n}\n","import { TurboModuleRegistry } from 'react-native';\n\nimport NativeModulesProxy from './NativeModulesProxy';\nimport { createTurboModuleToExpoProxy } from './TurboModuleToExpoModuleProxy';\nimport { ensureNativeModulesAreInstalled } from './ensureNativeModulesAreInstalled';\n\n/**\n * Imports the native module registered with given name. In the first place it tries to load\n * the module installed through the JSI host object and then falls back to the bridge proxy module.\n * Notice that the modules loaded from the proxy may not support some features like synchronous functions.\n *\n * @param moduleName Name of the requested native module.\n * @returns Object representing the native module.\n * @throws Error when there is no native module with given name.\n */\nexport function requireNativeModule<ModuleType = any>(moduleName: string): ModuleType {\n  const nativeModule = requireOptionalNativeModule<ModuleType>(moduleName);\n\n  if (!nativeModule) {\n    throw new Error(`Cannot find native module '${moduleName}'`);\n  }\n  return nativeModule;\n}\n\n/**\n * Imports the native module registered with the given name. The same as `requireNativeModule`,\n * but returns `null` when the module cannot be found instead of throwing an error.\n *\n * @param moduleName Name of the requested native module.\n * @returns Object representing the native module or `null` when it cannot be found.\n */\nexport function requireOptionalNativeModule<ModuleType = any>(\n  moduleName: string\n): ModuleType | null {\n  ensureNativeModulesAreInstalled();\n\n  try {\n    return (\n      globalThis.expo?.modules?.[moduleName] ??\n      NativeModulesProxy[moduleName] ??\n      createTurboModuleToExpoProxy(TurboModuleRegistry.get(moduleName), moduleName) ??\n      null\n    );\n  } catch (e) {\n    const error = e as Error;\n    console.warn(`An error occurred while requiring the '${moduleName}' module: ${error.message}`);\n    return null;\n  }\n}\n","declare const global: any;\n\n// In standard node environments there is no DOM API\nexport const isDOMAvailable = false;\nexport const canUseEventListeners = false;\nexport const canUseViewport = false;\n\nexport let isAsyncDebugging: boolean = false;\n\nif (__DEV__) {\n  // These native globals are injected by native React runtimes and not standard browsers\n  // we can use them to determine if the JS is being executed in Chrome.\n  isAsyncDebugging =\n    !global.nativeExtensions && !global.nativeCallSyncHook && !global.RN$Bridgeless;\n}\n","import { PlatformOSType, Platform as ReactNativePlatform } from 'react-native';\n\nimport {\n  isDOMAvailable,\n  canUseEventListeners,\n  canUseViewport,\n  isAsyncDebugging,\n} from './environment/browser';\n\nexport type PlatformSelectOSType = PlatformOSType | 'native' | 'electron' | 'default';\n\nexport type PlatformSelect = <T>(specifics: { [platform in PlatformSelectOSType]?: T }) => T;\n\nif (__DEV__ && typeof process.env.EXPO_OS === 'undefined') {\n  console.warn(\n    `The global process.env.EXPO_OS is not defined. This should be inlined by babel-preset-expo during transformation.`\n  );\n}\n\nconst nativeSelect =\n  typeof window !== 'undefined'\n    ? ReactNativePlatform.select\n    : // process.env.EXPO_OS is injected by `babel-preset-expo` and available in both client and `react-server` environments.\n      // Opt to use the env var when possible, and fallback to the React Native Platform module when it's not (arbitrary bundlers and transformers).\n      function select<T>(specifics: { [platform in PlatformSelectOSType]?: T }): T | undefined {\n        if (!process.env.EXPO_OS) return undefined;\n        if (specifics.hasOwnProperty(process.env.EXPO_OS)) {\n          return specifics[process.env.EXPO_OS as PlatformSelectOSType]!;\n        } else if (process.env.EXPO_OS !== 'web' && specifics.hasOwnProperty('native')) {\n          return specifics.native!;\n        } else if (specifics.hasOwnProperty('default')) {\n          return specifics.default!;\n        }\n        // do nothing...\n        return undefined;\n      };\n\nconst Platform = {\n  /**\n   * Denotes the currently running platform.\n   * Can be one of ios, android, web.\n   */\n  OS: process.env.EXPO_OS || ReactNativePlatform.OS,\n  /**\n   * Returns the value with the matching platform.\n   * Object keys can be any of ios, android, native, web, default.\n   *\n   * @ios ios, native, default\n   * @android android, native, default\n   * @web web, default\n   */\n  select: nativeSelect as PlatformSelect,\n  /**\n   * Denotes if the DOM API is available in the current environment.\n   * The DOM is not available in native React runtimes and Node.js.\n   */\n  isDOMAvailable,\n  /**\n   * Denotes if the current environment can attach event listeners\n   * to the window. This will return false in native React\n   * runtimes and Node.js.\n   */\n  canUseEventListeners,\n  /**\n   * Denotes if the current environment can inspect properties of the\n   * screen on which the current window is being rendered. This will\n   * return false in native React runtimes and Node.js.\n   */\n  canUseViewport,\n  /**\n   * If the JavaScript is being executed in a remote JavaScript environment.\n   * When `true`, synchronous native invocations cannot be executed.\n   */\n  isAsyncDebugging,\n};\n\nexport default Platform;\n","/**\n * A general error class that should be used for all errors in Expo modules.\n * Guarantees a `code` field that can be used to differentiate between different\n * types of errors without further subclassing Error.\n */\nexport class CodedError extends Error {\n  code: string;\n  info?: any;\n\n  constructor(code: string, message: string) {\n    super(message);\n    this.code = code;\n  }\n}\n","import { CodedError } from './CodedError';\nimport Platform from '../Platform';\n\n/**\n * A class for errors to be thrown when a property is accessed which is\n * unavailable, unsupported, or not currently implemented on the running\n * platform.\n */\nexport class UnavailabilityError extends CodedError {\n  constructor(moduleName: string, propertyName: string) {\n    super(\n      'ERR_UNAVAILABLE',\n      `The method or property ${moduleName}.${propertyName} is not available on ${Platform.OS}, are you sure you've linked all the native dependencies properly?`\n    );\n  }\n}\n","export enum PermissionStatus {\n  /**\n   * User has granted the permission.\n   */\n  GRANTED = 'granted',\n  /**\n   * User hasn't granted or denied the permission yet.\n   */\n  UNDETERMINED = 'undetermined',\n  /**\n   * User has denied the permission.\n   */\n  DENIED = 'denied',\n}\n\n/**\n * Permission expiration time. Currently, all permissions are granted permanently.\n */\nexport type PermissionExpiration = 'never' | number;\n\n/**\n * An object obtained by permissions get and request functions.\n */\nexport type PermissionResponse = {\n  /**\n   * Determines the status of the permission.\n   */\n  status: PermissionStatus;\n  /**\n   * Determines time when the permission expires.\n   */\n  expires: PermissionExpiration;\n  /**\n   * A convenience boolean that indicates if the permission is granted.\n   */\n  granted: boolean;\n  /**\n   * Indicates if user can be asked again for specific permission.\n   * If not, one should be directed to the Settings app\n   * in order to enable/disable the permission.\n   */\n  canAskAgain: boolean;\n};\n","// Copyright © 2024 650 Industries.\n\n'use client';\n\nimport { useCallback, useEffect, useRef, useState } from 'react';\n\nimport { PermissionResponse } from './PermissionsInterface';\n\n// These types are identical, but improves the readability for suggestions in editors\ntype RequestPermissionMethod<Permission extends PermissionResponse> = () => Promise<Permission>;\ntype GetPermissionMethod<Permission extends PermissionResponse> = () => Promise<Permission>;\n\ntype PermissionHookMethods<Permission extends PermissionResponse, Options = never> = {\n  /** The permission method that requests the user to grant permission. */\n  requestMethod: (options?: Options) => Promise<Permission>;\n  /** The permission method that only fetches the current permission status. */\n  getMethod: (options?: Options) => Promise<Permission>;\n};\n\ntype PermissionHookBehavior = {\n  /** If the hook should automatically fetch the current permission status, without asking the user. */\n  get?: boolean;\n  /** If the hook should automatically request the user to grant permission. */\n  request?: boolean;\n};\n\nexport type PermissionHookOptions<Options extends object> = PermissionHookBehavior & Options;\n\n/**\n * Get or request permission for protected functionality within the app.\n * It uses separate permission requesters to interact with a single permission.\n * By default, the hook will only retrieve the permission status.\n */\nfunction usePermission<Permission extends PermissionResponse, Options extends object>(\n  methods: PermissionHookMethods<Permission, Options>,\n  options?: PermissionHookOptions<Options>\n): [Permission | null, RequestPermissionMethod<Permission>, GetPermissionMethod<Permission>] {\n  const isMounted = useRef(true);\n  const [status, setStatus] = useState<Permission | null>(null);\n  const { get = true, request = false, ...permissionOptions } = options || {};\n\n  const getPermission = useCallback(async () => {\n    let response: Permission;\n    if (Object.keys(permissionOptions).length > 0) {\n      response = await methods.getMethod(permissionOptions as Options);\n    } else {\n      response = await methods.getMethod();\n    }\n    if (isMounted.current) setStatus(response);\n    return response;\n  }, [methods.getMethod]);\n\n  const requestPermission = useCallback(async () => {\n    let response: Permission;\n    if (Object.keys(permissionOptions).length > 0) {\n      response = await methods.requestMethod(permissionOptions as Options);\n    } else {\n      response = await methods.requestMethod();\n    }\n    if (isMounted.current) setStatus(response);\n    return response;\n  }, [methods.requestMethod]);\n\n  useEffect(\n    function runMethods() {\n      if (request) requestPermission();\n      if (!request && get) getPermission();\n    },\n    [get, request, requestPermission, getPermission]\n  );\n\n  // Workaround for unmounting components receiving state updates\n  useEffect(function didMount() {\n    isMounted.current = true;\n    return () => {\n      isMounted.current = false;\n    };\n  }, []);\n\n  return [status, requestPermission, getPermission];\n}\n\n/**\n * Create a new permission hook with the permission methods built-in.\n * This can be used to quickly create specific permission hooks in every module.\n */\nexport function createPermissionHook<Permission extends PermissionResponse, Options extends object>(\n  methods: PermissionHookMethods<Permission, Options>\n) {\n  return (options?: PermissionHookOptions<Options>) =>\n    usePermission<Permission, Options>(methods, options);\n}\n","import { requireNativeModule } from 'expo-modules-core';\n// TODO: Rename the package to 'ExpoTracking'\nexport default requireNativeModule('ExpoTrackingTransparency');\n//# sourceMappingURL=ExpoTrackingTransparency.js.map","import { PermissionStatus, UnavailabilityError, createPermissionHook, } from 'expo-modules-core';\nimport { Platform } from 'react-native';\nimport ExpoTrackingTransparency from './ExpoTrackingTransparency';\n/**\n * Gets the advertising ID, a UUID string intended only for advertising. Use this string for\n * frequency capping, attribution, conversion events, estimating the number of unique users,\n * advertising fraud detection, and debugging.\n *\n * As a best practice, don't store the advertising ID. Instead, call this function each time your\n * app needs to use the advertising ID. Users can change whether they allow app tracking and can\n * reset their advertising ID at any time in their system settings. Check your app's authorization\n * using `getTrackingPermissionsAsync()` to determine the user's intent.\n *\n * On Android, this function returns the \"Android Advertising ID\"\n * ([AAID](https://developers.google.com/android/reference/com/google/android/gms/ads/identifier/AdvertisingIdClient.Info#public-string-getid)).\n * On Android devices that support multiple users, including guest users, it's possible for your app\n * to obtain different advertising IDs on the same device. These different IDs correspond to\n * different users who could be signed in on that device. See Google's documentation for more\n * information: [Get a user-resettable advertising\n * ID](https://developer.android.com/training/articles/ad-id).\n *\n * On iOS, this function returns the \"Identifier for Advertisers\"\n * ([IDFA](https://developer.apple.com/documentation/adsupport/asidentifiermanager/advertisingidentifier)),\n * a string that's unique to each device. On devices running iOS 14.5 and newer, your app must\n * request tracking authorization using `requestTrackingPermissionsAsync()` before it can get the\n * advertising identifier.\n *\n * @return Returns either a UUID `string` or `null`. It returns null in the following cases:\n * - On Android, when `isLimitAdTrackingEnabled()` is `true`\n * - In the iOS simulator, regardless of any settings\n * - On devices running iOS 14.5 and later if you haven't received permission using\n *   `requestTrackingPermissionsAsync()`\n * - On iOS, if you've requested permission and the user declines\n * - On iOS, when a profile or configuration restricts access to the advertising identifier, such as\n *   when the user has turned off the system-wide \"Allow Apps to Request to Track\" setting\n *\n * @example\n * ```ts\n * TrackingTransparency.getAdvertisingId();\n * // \"E9228286-4C4E-4789-9D95-15827DCB291B\"\n * ```\n */\nexport function getAdvertisingId() {\n    const advertisingId = ExpoTrackingTransparency.getAdvertisingId();\n    if (advertisingId === '00000000-0000-0000-0000-000000000000') {\n        return null;\n    }\n    return advertisingId;\n}\nconst androidAndWebPermissionsResponse = {\n    granted: true,\n    expires: 'never',\n    canAskAgain: true,\n    status: PermissionStatus.GRANTED,\n};\n/**\n * Requests the user to authorize or deny access to app-related data that can be used for tracking\n * the user or the device. Examples of data used for tracking include email address, device ID,\n * advertising ID, etc. On iOS 14.5 and above, if the user denies this permission, any attempt to\n * collect the IDFA will return a string of 0s.\n *\n * The system remembers the user’s choice and doesn’t prompt again unless a user uninstalls and then\n * reinstalls the app on the device.\n *\n * On Android, web, and iOS 13 and below, this method always returns that the permission was\n * granted.\n * @example\n * ```typescript\n * const { granted } = await requestTrackingPermissionsAsync();\n *\n * if (granted) {\n *   // Your app is authorized to track the user or their device\n * }\n * ```\n */\nexport async function requestTrackingPermissionsAsync() {\n    if (Platform.OS !== 'ios') {\n        return Promise.resolve(androidAndWebPermissionsResponse);\n    }\n    if (!ExpoTrackingTransparency.requestPermissionsAsync) {\n        throw new UnavailabilityError('TrackingTransparency', 'requestPermissionsAsync');\n    }\n    return await ExpoTrackingTransparency.requestPermissionsAsync();\n}\n/**\n * Checks whether or not the user has authorized the app to access app-related data that can be used\n * for tracking the user or the device. See `requestTrackingPermissionsAsync` for more details.\n *\n * On Android, web, and iOS 13 and below, this method always returns that the permission was\n * granted.\n *\n * @example\n * ```typescript\n * const { granted } = await getTrackingPermissionsAsync();\n *\n * if (granted) {\n *   // Your app is authorized to track the user or their device\n * }\n * ```\n */\nexport async function getTrackingPermissionsAsync() {\n    if (Platform.OS !== 'ios') {\n        return Promise.resolve(androidAndWebPermissionsResponse);\n    }\n    if (!ExpoTrackingTransparency.getPermissionsAsync) {\n        throw new UnavailabilityError('TrackingTransparency', 'getPermissionsAsync');\n    }\n    return await ExpoTrackingTransparency.getPermissionsAsync();\n}\n/**\n * Check or request the user to authorize or deny access to app-related data that can be used for tracking\n * the user or the device. Examples of data used for tracking include email address, device ID,\n * advertising ID, etc. On iOS 14.5 and above, if the user denies this permission, any attempt to\n * collect the IDFA will return a string of 0s.\n *\n * The system remembers the user’s choice and doesn’t prompt again unless a user uninstalls and then\n * reinstalls the app on the device.\n *\n * On Android, web, and iOS 13 and below, this method always returns that the permission was\n * granted.\n * @example\n * ```ts\n * const [status, requestPermission] = useTrackingPermissions();\n * ```\n */\nexport const useTrackingPermissions = createPermissionHook({\n    getMethod: getTrackingPermissionsAsync,\n    requestMethod: requestTrackingPermissionsAsync,\n});\n/**\n * Returns whether the TrackingTransparency API is available on the current device.\n *\n * @returns On devices where the Tracking Transparency API is unavailable,\n * the get and request permissions methods will always resolve to `granted`.\n */\nexport function isAvailable() {\n    return Boolean(ExpoTrackingTransparency);\n}\nexport { PermissionStatus };\n//# sourceMappingURL=TrackingTransparency.js.map"],"x_google_ignoreList":[0,1,2,3,4,5,6,7,8,9,10,11],"mappings":"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"}