@symbiote-native/tracking-transparency 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 A. Prokopenko
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,210 @@
+# @symbiote-native/tracking-transparency
+
+A wrapper package for [SymbioteNative](../../README.md) that makes
+[`expo-tracking-transparency`](https://github.com/expo/expo/tree/main/packages/expo-tracking-transparency)
+— the iOS App Tracking Transparency prompt, permission get/request, and the advertising-ID getter
+— usable from **every** adapter, React, Vue, and Angular, not just React. Like
+[`@symbiote-native/brightness`](../brightness), this package's surface is mostly stateless free
+async functions; only the permission surface gets its own lifecycle hook/composable/service,
+mirroring upstream's own `usePermissions`. Built the same way as
+[`@symbiote-native/local-auth`](../local-auth), [`@symbiote-native/battery`](../battery), and
+[`@symbiote-native/brightness`](../brightness) — an `expo-modules-core`-based wrapper (see the
+`symbiote-expo-native-module` project skill for the full mechanism: why `expo-modules-core` is
+depended on directly and never the `expo` meta-package, why the upstream JS is hand-ported into
+`core/` rather than imported, and how autolinking picks up the native module).
+
+This is a **permission-hook package**: on iOS it drives the real ATT prompt; on Android and web
+there is no such concept, so every permission call always resolves granted, matching upstream
+exactly.
+
+## Install
+
+```bash
+npm install @symbiote-native/tracking-transparency
+```
+
+`expo-tracking-transparency` and `expo-modules-core` come along as regular, pinned dependencies —
+never install either yourself, and never add the `expo` meta-package to this project (it bundles
+its own Metro/Babel pipeline that conflicts with this project's own).
+
+### Required one-time step: native autolinking wiring
+
+Unlike a plain RN native module, `expo-tracking-transparency`'s native code is discovered by
+`expo-modules-autolinking`, not the `react-native.config.cjs`/podspec mechanism other wrappers in
+this repo use — this needs wiring into the native host app **once**, covering this package and
+every other `expo-modules-core` package with zero further changes:
+
+| Platform | Touches |
+|---|---|
+| iOS | `ios/Podfile` — add `use_expo_modules!` |
+| iOS | `AppDelegate.swift` — Expo's runtime-bootstrap hook |
+| iOS | `Info.plist` — `NSUserTrackingUsageDescription`, required to show the ATT prompt |
+| Android | `settings.gradle` / `app/build.gradle` — resolve and include the Expo Gradle projects |
+| Android | `MainApplication.kt` — Expo's bootstrap hook, plus a hand-written native-module name map (there's no `expo` meta-package here to auto-generate one) |
+
+Full mechanics — the Podfile pieces that normally ship inside the `expo` package, the `expo`
+peer-dependency exclusion list — live in the `symbiote-expo-native-module` skill. The Android
+native module also pulls in `com.google.android.gms:play-services-ads-identifier:18.0.1`
+transitively via `expo-tracking-transparency`'s own `android/build.gradle` — automatic once the
+module project is included, no extra wiring needed on our side.
+
+## Shape
+
+```
+src/core/                 getAdvertisingId, get/requestTrackingPermissionsAsync, isAvailable;
+                          native-module.ts resolves ExpoTrackingTransparency through
+                          expo-modules-core's requireNativeModule.
+src/react/hooks/           @symbiote-native/tracking-transparency/react   — usePermissions
+src/vue/composables/       @symbiote-native/tracking-transparency/vue     — usePermissions (same name)
+src/angular/services/      @symbiote-native/tracking-transparency/angular — PermissionsService
+```
+
+Each adapter's hook/composable/service wraps the same one-shot `getTrackingPermissionsAsync`/
+`requestTrackingPermissionsAsync` pair in its own lifecycle idiom (auto-fetch on mount, exposed as
+a tuple/object/signal). `getAdvertisingId`/`isAvailable` are stateless free-function re-exports,
+written once in `core/` and shared verbatim by all three adapters.
+
+Upstream's own `createPermissionHook`/`useTrackingPermissions` is **not** ported — that helper is
+React-only (built on `useState`/`useEffect`), and this repo's convention is for each adapter to
+hand-roll its own permission hook instead, exactly like `brightness`/`cellular` already do.
+
+## Use it
+
+```tsx
+// React
+import { usePermissions } from '@symbiote-native/tracking-transparency/react';
+import { getAdvertisingId } from '@symbiote-native/tracking-transparency';
+
+function TrackingScreen() {
+  const [permissionStatus, requestPermission] = usePermissions();
+
+  return (
+    <View>
+      <Text>{permissionStatus?.status ?? 'checking…'}</Text>
+      <Pressable onPress={() => requestPermission()}>
+        <Text>Request tracking permission</Text>
+      </Pressable>
+      <Pressable onPress={() => console.log(getAdvertisingId())}>
+        <Text>Log advertising ID</Text>
+      </Pressable>
+    </View>
+  );
+}
+```
+
+```vue
+<!-- Vue -->
+<script setup lang="ts">
+import { usePermissions } from '@symbiote-native/tracking-transparency/vue';
+import { getAdvertisingId } from '@symbiote-native/tracking-transparency';
+
+const { status: permissionStatus, request: requestPermission } = usePermissions();
+</script>
+
+<template>
+  <View>
+    <Text>{{ permissionStatus?.status ?? 'checking…' }}</Text>
+    <Pressable @press="requestPermission()">
+      <Text>Request tracking permission</Text>
+    </Pressable>
+    <Pressable @press="console.log(getAdvertisingId())">
+      <Text>Log advertising ID</Text>
+    </Pressable>
+  </View>
+</template>
+```
+
+```ts
+// Angular
+import { Component, inject } from '@angular/core';
+import { PermissionsService, getAdvertisingId } from '@symbiote-native/tracking-transparency/angular';
+
+@Component({
+  selector: 'TrackingScreen',
+  standalone: true,
+  template: `
+    <View>
+      <Text>{{ permissionStatus()?.status ?? 'checking…' }}</Text>
+      <Pressable (press)="permissionsService.request()">
+        <Text>Request tracking permission</Text>
+      </Pressable>
+      <Pressable (press)="logAdvertisingId()"><Text>Log advertising ID</Text></Pressable>
+    </View>
+  `,
+})
+export class TrackingScreen {
+  protected readonly permissionsService = inject(PermissionsService);
+  readonly permissionStatus = this.permissionsService.connect();
+
+  logAdvertisingId(): void {
+    console.log(getAdvertisingId());
+  }
+}
+```
+
+## API
+
+```ts
+getAdvertisingId(): string | null
+// The advertising ID (Android AAID / iOS IDFA). Returns null on the iOS simulator, when tracking
+// hasn't been authorized via requestTrackingPermissionsAsync, or when the user declined.
+
+getTrackingPermissionsAsync(): Promise<PermissionResponse>
+requestTrackingPermissionsAsync(): Promise<PermissionResponse>
+// On Android and web these always resolve granted — there is no tracking-consent concept there.
+// On iOS these drive the real ATT prompt / read its current status.
+
+isAvailable(): boolean
+// Whether the native module resolved at all.
+```
+
+Plus `PermissionStatus`/`PermissionResponse`/`PermissionExpiration`/`PermissionHookOptions` —
+re-exported verbatim from `expo-modules-core`, never the `expo` meta-package.
+
+```ts
+import { getAdvertisingId, getTrackingPermissionsAsync } from '@symbiote-native/tracking-transparency';
+
+// framework-scoped entry points re-export the same free functions, plus a usePermissions
+// hook/composable/service:
+import { usePermissions } from '@symbiote-native/tracking-transparency/react';
+import { usePermissions } from '@symbiote-native/tracking-transparency/vue';
+import { PermissionsService } from '@symbiote-native/tracking-transparency/angular';
+```
+
+`usePermissions` (React/Vue) auto-fetches the current permission status on mount and returns a
+`[status, request, get]` tuple (React) / `{ status, request, get }` object (Vue); Angular's
+`PermissionsService.connect()` does the same, returning a readonly `Signal`:
+
+```ts
+// React
+const [status, request] = usePermissions();
+
+// Vue
+const { status, request } = usePermissions();
+
+// Angular
+readonly status = inject(PermissionsService).connect();
+```
+
+## Platform notes
+
+- **Android and web always report granted.** There is no tracking-consent concept on either
+  platform — `getTrackingPermissionsAsync`/`requestTrackingPermissionsAsync` short-circuit to a
+  fixed granted response without ever calling the native module, matching upstream exactly.
+- **`getAdvertisingId` returns `null` on the iOS Simulator, regardless of any settings** — there is
+  no real IDFA to read there. This is expected Apple Simulator behavior, not a bug in this wrapper.
+
+## Test it
+
+No Fabric/Descriptor angle at all — tracking-transparency is a pure async-function + permission
+surface, never a view. Tests inject a fake native-module object in place of the real
+`requireNativeModule` resolution (`src/core/*.test.ts`, `src/{react,vue,angular}/**/*.test.{ts,tsx}`,
+`vitest`), the same pattern `expo-tracking-transparency` itself uses upstream — no
+`installFabric()` for the core layer, no ViewConfig. Native rendering itself is verified on-device
+(see the parent [README](../../README.md) for the project's testing model).
+
+## Known gaps
+
+- Not yet wired into any `examples/expo-*` canary.
+- Tests exercise the JS layer only (fake native module, `vitest`) — no on-device/simulator
+  automated smoke test yet, only manual verification.

package/build/angular/index.d.ts

@@ -0,0 +1,2 @@
+export { PermissionsService } from './services/permissions.service';
+export * from '../core';

package/build/angular/index.js

@@ -0,0 +1,4 @@
+// PermissionsService is the Angular-only lifecycle half; getAdvertisingId/isAvailable are
+// stateless free functions, shared with React/Vue.
+export { PermissionsService } from './services/permissions.service';
+export * from '../core';

package/build/angular/services/permissions.service/index.d.ts

@@ -0,0 +1,8 @@
+import { type Signal } from '@angular/core';
+import { type PermissionResponse } from '../../../core';
+export declare class PermissionsService {
+    private readonly status;
+    connect(): Signal<PermissionResponse | null>;
+    get(): Promise<PermissionResponse>;
+    request(): Promise<PermissionResponse>;
+}

package/build/angular/services/permissions.service/index.js

@@ -0,0 +1,78 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+// Angular twin of React's usePermissions hook and Vue's usePermissions composable.
+// `connect()` auto-fetches once (no ongoing subscription to clean up, so no Injector/effect
+// needed, unlike BatteryStateService) and returns a readonly signal; get()/request() are
+// imperative one-shot methods.
+//
+//   readonly status = inject(PermissionsService).connect();
+//   // template: {{ status()?.granted }}
+import { Injectable, signal } from '@angular/core';
+import { getTrackingPermissionsAsync, requestTrackingPermissionsAsync, } from '../../../core';
+let PermissionsService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var PermissionsService = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            PermissionsService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        status = signal(null);
+        connect() {
+            if (this.status() === null) {
+                void this.get();
+            }
+            return this.status.asReadonly();
+        }
+        async get() {
+            const response = await getTrackingPermissionsAsync();
+            this.status.set(response);
+            return response;
+        }
+        async request() {
+            const response = await requestTrackingPermissionsAsync();
+            this.status.set(response);
+            return response;
+        }
+    };
+    return PermissionsService = _classThis;
+})();
+export { PermissionsService };

package/build/core/index.d.ts

@@ -0,0 +1,2 @@
+export { getAdvertisingId, requestTrackingPermissionsAsync, getTrackingPermissionsAsync, isAvailable, } from './tracking-transparency';
+export { PermissionStatus, type PermissionResponse, type PermissionExpiration, type PermissionHookOptions, } from 'expo-modules-core';

package/build/core/index.js

@@ -0,0 +1,2 @@
+export { getAdvertisingId, requestTrackingPermissionsAsync, getTrackingPermissionsAsync, isAvailable, } from './tracking-transparency';
+export { PermissionStatus, } from 'expo-modules-core';

package/build/core/native-module.d.ts

@@ -0,0 +1,7 @@
+import type { PermissionResponse } from 'expo-modules-core';
+export type INativeTrackingTransparencyModule = {
+    getAdvertisingId(): string | null;
+    requestPermissionsAsync?(): Promise<PermissionResponse>;
+    getPermissionsAsync?(): Promise<PermissionResponse>;
+};
+export declare const expoTrackingTransparency: INativeTrackingTransparencyModule;

package/build/core/native-module.js

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPO_TRACKING_TRANSPARENCY_MODULE_NAME = 'ExpoTrackingTransparency';
+export const expoTrackingTransparency = requireNativeModule(EXPO_TRACKING_TRANSPARENCY_MODULE_NAME);

package/build/core/tracking-transparency.d.ts

@@ -0,0 +1,19 @@
+import type { PermissionResponse } from 'expo-modules-core';
+/**
+ * Gets the advertising ID, a UUID string intended only for advertising. Returns `null` on the
+ * iOS simulator, when tracking hasn't been authorized via `requestTrackingPermissionsAsync`, or
+ * when the user declined.
+ */
+export declare function getAdvertisingId(): string | null;
+/**
+ * Requests the user to authorize or deny access to app-related data that can be used for
+ * tracking. On Android and web this always resolves granted.
+ */
+export declare function requestTrackingPermissionsAsync(): Promise<PermissionResponse>;
+/**
+ * Checks whether the user has authorized the app to access tracking-related data. On Android and
+ * web this always resolves granted.
+ */
+export declare function getTrackingPermissionsAsync(): Promise<PermissionResponse>;
+/** Whether the tracking-transparency native module resolved at all. */
+export declare function isAvailable(): boolean;

package/build/core/tracking-transparency.js

@@ -0,0 +1,58 @@
+// Hand-ported from .vendors/expo/packages/expo-tracking-transparency/src/TrackingTransparency.ts
+// (sdk-57, verified via `git -C .vendors/expo show origin/sdk-57:...` — the vendored working
+// tree is on `main` and imports createPermissionHook/PermissionResponse from the `expo`
+// meta-package instead of expo-modules-core). createPermissionHook/useTrackingPermissions are
+// NOT ported here — that helper is React-only (built on useState/useEffect), and this repo's
+// convention is for each adapter to hand-roll its own permission hook instead (react/hooks,
+// vue/composables, angular/services), same as brightness/cellular already do.
+import { Platform, PermissionStatus, UnavailabilityError } from 'expo-modules-core';
+import { expoTrackingTransparency } from './native-module';
+const NATIVE_MODULE_NAME = 'TrackingTransparency';
+/**
+ * Gets the advertising ID, a UUID string intended only for advertising. Returns `null` on the
+ * iOS simulator, when tracking hasn't been authorized via `requestTrackingPermissionsAsync`, or
+ * when the user declined.
+ */
+export function getAdvertisingId() {
+    const advertisingId = expoTrackingTransparency.getAdvertisingId();
+    if (advertisingId === '00000000-0000-0000-0000-000000000000') {
+        return null;
+    }
+    return advertisingId;
+}
+const androidAndWebPermissionsResponse = {
+    granted: true,
+    expires: 'never',
+    canAskAgain: true,
+    status: PermissionStatus.GRANTED,
+};
+/**
+ * Requests the user to authorize or deny access to app-related data that can be used for
+ * tracking. On Android and web this always resolves granted.
+ */
+export async function requestTrackingPermissionsAsync() {
+    if (Platform.OS !== 'ios') {
+        return Promise.resolve(androidAndWebPermissionsResponse);
+    }
+    if (!expoTrackingTransparency.requestPermissionsAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'requestPermissionsAsync');
+    }
+    return await expoTrackingTransparency.requestPermissionsAsync();
+}
+/**
+ * Checks whether the user has authorized the app to access tracking-related data. On Android and
+ * web this always resolves granted.
+ */
+export async function getTrackingPermissionsAsync() {
+    if (Platform.OS !== 'ios') {
+        return Promise.resolve(androidAndWebPermissionsResponse);
+    }
+    if (!expoTrackingTransparency.getPermissionsAsync) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'getPermissionsAsync');
+    }
+    return await expoTrackingTransparency.getPermissionsAsync();
+}
+/** Whether the tracking-transparency native module resolved at all. */
+export function isAvailable() {
+    return Boolean(expoTrackingTransparency);
+}

package/build/react/hooks/use-permissions/index.d.ts

@@ -0,0 +1,6 @@
+import { type PermissionResponse } from '../../../core';
+export declare function usePermissions(): [
+    PermissionResponse | null,
+    () => Promise<PermissionResponse>,
+    () => Promise<PermissionResponse>
+];

package/build/react/hooks/use-permissions/index.js

@@ -0,0 +1,30 @@
+// React lifecycle wiring over the framework-agnostic core (core/tracking-transparency.ts) —
+// auto-fetches the current permission status on mount, then exposes get/request as imperative
+// callbacks. Mirrors the shape @symbiote-native/cellular's own usePermissions ships in parallel,
+// so both stay byte-for-byte consistent.
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { getTrackingPermissionsAsync, requestTrackingPermissionsAsync, } from '../../../core';
+export function usePermissions() {
+    const isMounted = useRef(true);
+    const [status, setStatus] = useState(null);
+    const getPermission = useCallback(async () => {
+        const response = await getTrackingPermissionsAsync();
+        if (isMounted.current)
+            setStatus(response);
+        return response;
+    }, []);
+    const requestPermission = useCallback(async () => {
+        const response = await requestTrackingPermissionsAsync();
+        if (isMounted.current)
+            setStatus(response);
+        return response;
+    }, []);
+    useEffect(() => {
+        isMounted.current = true;
+        void getPermission();
+        return () => {
+            isMounted.current = false;
+        };
+    }, [getPermission]);
+    return [status, requestPermission, getPermission];
+}

package/build/react/index.d.ts

@@ -0,0 +1,2 @@
+export { usePermissions } from './hooks/use-permissions';
+export * from '../core';

package/build/react/index.js

@@ -0,0 +1,6 @@
+// @symbiote-native/tracking-transparency/react: the React entry over the framework-agnostic
+// core. Only the permission surface gets a lifecycle hook (there is per-instance state to seed
+// and refresh); getAdvertisingId/isAvailable are stateless, re-exported verbatim — mirrors the
+// lifecycle-bucket naming convention of adapters/react/src/hooks.
+export { usePermissions } from './hooks/use-permissions';
+export * from '../core';

package/build/vue/composables/use-permissions/index.d.ts

@@ -0,0 +1,7 @@
+import { type Ref } from '@vue/runtime-core';
+import { type PermissionResponse } from '../../../core';
+export declare function usePermissions(): {
+    status: Ref<PermissionResponse | null>;
+    request: () => Promise<PermissionResponse>;
+    get: () => Promise<PermissionResponse>;
+};

package/build/vue/composables/use-permissions/index.js

@@ -0,0 +1,23 @@
+// Vue lifecycle wiring over the framework-agnostic core (core/tracking-transparency.ts) —
+// auto-fetches the current permission status on mount (mirrors use-battery-level's
+// onMounted/onUnmounted style, but there is no ongoing subscription to tear down here, just a
+// one-shot get), then exposes get/request as imperative callbacks.
+import { onMounted, ref } from '@vue/runtime-core';
+import { getTrackingPermissionsAsync, requestTrackingPermissionsAsync, } from '../../../core';
+export function usePermissions() {
+    const status = ref(null);
+    const get = async () => {
+        const response = await getTrackingPermissionsAsync();
+        status.value = response;
+        return response;
+    };
+    const request = async () => {
+        const response = await requestTrackingPermissionsAsync();
+        status.value = response;
+        return response;
+    };
+    onMounted(() => {
+        void get();
+    });
+    return { status, request, get };
+}

package/build/vue/index.d.ts

@@ -0,0 +1,2 @@
+export { usePermissions } from './composables/use-permissions';
+export * from '../core';

package/build/vue/index.js

@@ -0,0 +1,6 @@
+// @symbiote-native/tracking-transparency/vue: the Vue entry over the framework-agnostic core.
+// Same reasoning as the React entry — only the permission surface gets a lifecycle composable,
+// every other export is a plain re-export — mirrors the lifecycle-bucket naming convention of
+// adapters/vue/src/composables (never `hooks/`, that's React's term).
+export { usePermissions } from './composables/use-permissions';
+export * from '../core';

package/build-ngc/angular/index.d.ts

@@ -0,0 +1,2 @@
+export { PermissionsService } from './services/permissions.service';
+export * from '../core';

package/build-ngc/angular/index.js

@@ -0,0 +1,5 @@
+// PermissionsService is the Angular-only lifecycle half; getAdvertisingId/isAvailable are
+// stateless free functions, shared with React/Vue.
+export { PermissionsService } from './services/permissions.service';
+export * from '../core';
+//# sourceMappingURL=index.js.map

package/build-ngc/angular/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/angular/index.ts"],"names":[],"mappings":"AAAA,0FAA0F;AAC1F,mDAAmD;AACnD,OAAO,EAAE,kBAAkB,EAAE,MAAM,gCAAgC,CAAC;AACpE,cAAc,SAAS,CAAC"}

package/build-ngc/angular/services/permissions.service/index.d.ts

@@ -0,0 +1,11 @@
+import { type Signal } from '@angular/core';
+import { type PermissionResponse } from '../../../core';
+import * as i0 from "@angular/core";
+export declare class PermissionsService {
+    private readonly status;
+    connect(): Signal<PermissionResponse | null>;
+    get(): Promise<PermissionResponse>;
+    request(): Promise<PermissionResponse>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<PermissionsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<PermissionsService>;
+}

package/build-ngc/angular/services/permissions.service/index.js

@@ -0,0 +1,37 @@
+// Angular twin of React's usePermissions hook and Vue's usePermissions composable.
+// `connect()` auto-fetches once (no ongoing subscription to clean up, so no Injector/effect
+// needed, unlike BatteryStateService) and returns a readonly signal; get()/request() are
+// imperative one-shot methods.
+//
+//   readonly status = inject(PermissionsService).connect();
+//   // template: {{ status()?.granted }}
+import { Injectable, signal } from '@angular/core';
+import { getTrackingPermissionsAsync, requestTrackingPermissionsAsync, } from '../../../core';
+import * as i0 from "@angular/core";
+export class PermissionsService {
+    status = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "status" }] : /* istanbul ignore next */ []));
+    connect() {
+        if (this.status() === null) {
+            void this.get();
+        }
+        return this.status.asReadonly();
+    }
+    async get() {
+        const response = await getTrackingPermissionsAsync();
+        this.status.set(response);
+        return response;
+    }
+    async request() {
+        const response = await requestTrackingPermissionsAsync();
+        this.status.set(response);
+        return response;
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: PermissionsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: PermissionsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: PermissionsService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=index.js.map

package/build-ngc/angular/services/permissions.service/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/angular/services/permissions.service/index.ts"],"names":[],"mappings":"AAAA,mFAAmF;AACnF,4FAA4F;AAC5F,yFAAyF;AACzF,+BAA+B;AAC/B,EAAE;AACF,4DAA4D;AAC5D,yCAAyC;AACzC,OAAO,EAAE,UAAU,EAAE,MAAM,EAAe,MAAM,eAAe,CAAC;AAChE,OAAO,EACL,2BAA2B,EAC3B,+BAA+B,GAEhC,MAAM,eAAe,CAAC;;AAGvB,MAAM,OAAO,kBAAkB;IACZ,MAAM,GAAG,MAAM,CAA4B,IAAI;+EAAC,CAAC;IAElE,OAAO;QACL,IAAI,IAAI,CAAC,MAAM,EAAE,KAAK,IAAI,EAAE,CAAC;YAC3B,KAAK,IAAI,CAAC,GAAG,EAAE,CAAC;QAClB,CAAC;QACD,OAAO,IAAI,CAAC,MAAM,CAAC,UAAU,EAAE,CAAC;IAClC,CAAC;IAED,KAAK,CAAC,GAAG;QACP,MAAM,QAAQ,GAAG,MAAM,2BAA2B,EAAE,CAAC;QACrD,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC1B,OAAO,QAAQ,CAAC;IAClB,CAAC;IAED,KAAK,CAAC,OAAO;QACX,MAAM,QAAQ,GAAG,MAAM,+BAA+B,EAAE,CAAC;QACzD,IAAI,CAAC,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QAC1B,OAAO,QAAQ,CAAC;IAClB,CAAC;uGApBU,kBAAkB;2GAAlB,kBAAkB,cADL,MAAM;;2FACnB,kBAAkB;kBAD9B,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE"}

package/build-ngc/core/index.d.ts

@@ -0,0 +1,2 @@
+export { getAdvertisingId, requestTrackingPermissionsAsync, getTrackingPermissionsAsync, isAvailable, } from './tracking-transparency';
+export { PermissionStatus, type PermissionResponse, type PermissionExpiration, type PermissionHookOptions, } from 'expo-modules-core';

package/build-ngc/core/index.js

@@ -0,0 +1,3 @@
+export { getAdvertisingId, requestTrackingPermissionsAsync, getTrackingPermissionsAsync, isAvailable, } from './tracking-transparency';
+export { PermissionStatus, } from 'expo-modules-core';
+//# sourceMappingURL=index.js.map

package/build-ngc/core/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,+BAA+B,EAC/B,2BAA2B,EAC3B,WAAW,GACZ,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,gBAAgB,GAIjB,MAAM,mBAAmB,CAAC"}

package/build-ngc/core/native-module.d.ts

@@ -0,0 +1,7 @@
+import type { PermissionResponse } from 'expo-modules-core';
+export type INativeTrackingTransparencyModule = {
+    getAdvertisingId(): string | null;
+    requestPermissionsAsync?(): Promise<PermissionResponse>;
+    getPermissionsAsync?(): Promise<PermissionResponse>;
+};
+export declare const expoTrackingTransparency: INativeTrackingTransparencyModule;

package/build-ngc/core/native-module.js

@@ -0,0 +1,4 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPO_TRACKING_TRANSPARENCY_MODULE_NAME = 'ExpoTrackingTransparency';
+export const expoTrackingTransparency = requireNativeModule(EXPO_TRACKING_TRANSPARENCY_MODULE_NAME);
+//# sourceMappingURL=native-module.js.map

package/build-ngc/core/native-module.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"native-module.js","sourceRoot":"","sources":["../../src/core/native-module.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,mBAAmB,CAAC;AAGxD,MAAM,sCAAsC,GAAG,0BAA0B,CAAC;AAe1E,MAAM,CAAC,MAAM,wBAAwB,GAAG,mBAAmB,CACzD,sCAAsC,CACvC,CAAC"}