@symbiote-native/tracking-transparency 3.0.1 → 3.1.0

package/README.md

@@ -1,14 +1,14 @@
 # @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, Svelte, Solid, and Angular, not just React. Like
+[`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, Svelte, Solid, 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 per-adapter lifecycle wrapper,
-mirroring upstream's own `usePermissions`. Built the same way as
+mirroring upstream's own `useTrackingPermissions`. 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-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).
@@ -32,16 +32,16 @@ npx @symbiote-native/cli add --tracking-transparency
 ```
 
 Either way: installs `@symbiote-native/tracking-transparency` and wires the native autolinking
-automatically — see [`@symbiote-native/cli`](../cli).
+automatically - see [`@symbiote-native/cli`](../cli).
 
 <details>
-<summary>Manual install (no CLI — installing and wiring native autolinking by hand)</summary>
+<summary>Manual install (no CLI - installing and wiring native autolinking by hand)</summary>
 
 ```bash
 npm install @symbiote-native/tracking-transparency
 ```
 
-`expo-tracking-transparency` and `expo-modules-core` come along as regular, pinned dependencies —
+`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).
 
@@ -49,21 +49,21 @@ its own Metro/Babel pipeline that conflicts with this project's own).
 
 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
+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
+| 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
+transitively via `expo-tracking-transparency`'s own `android/build.gradle` - automatic once the
 module project is included, no extra wiring needed on our side.
 
 </details>
@@ -74,32 +74,31 @@ module project is included, no extra wiring needed on our side.
 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/svelte/runes/          @symbiote-native/tracking-transparency/svelte  — usePermissions (same name)
-src/solid/primitives/      @symbiote-native/tracking-transparency/solid   — createPermissions
-                           (Solid reserves `use*` for consuming existing state)
-src/angular/services/      @symbiote-native/tracking-transparency/angular — PermissionsService
+src/react/                 @symbiote-native/tracking-transparency/react: useTrackingPermissions
+src/vue/                   @symbiote-native/tracking-transparency/vue: useTrackingPermissions
+src/svelte/                @symbiote-native/tracking-transparency/svelte: useTrackingPermissions
+src/solid/                 @symbiote-native/tracking-transparency/solid: useTrackingPermissions
+src/angular/               @symbiote-native/tracking-transparency/angular: TrackingPermissionsService
 ```
 
-Each adapter's wrapper puts the same one-shot `getTrackingPermissionsAsync`/
-`requestTrackingPermissionsAsync` pair in its own lifecycle idiom (auto-fetch when the wrapper is
-created, exposed as a tuple/object/signal/accessor). `getAdvertisingId`/`isAvailable` are stateless
-free-function re-exports, written once in `core/` and shared verbatim by every adapter.
+Each adapter binds the same `getTrackingPermissionsAsync`/`requestTrackingPermissionsAsync` pair
+(`core/tracking-permission-api.ts`) to the shared `createPermissionHook` of its adapter, or to
+`PermissionsServiceBase` on Angular. `getAdvertisingId`/`isAvailable` are stateless free-function
+re-exports, written once in `core/` and shared verbatim by every adapter.
 
-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.
+`useTrackingPermissions` takes upstream's `{ get, request }` options: it fetches on mount by
+default, `{ request: true }` asks instead, `{ get: false }` does nothing until called. Unlike the
+former `usePermissions`, the hooks carry no `error` slot; Angular's service keeps `error`.
 
 ## Use it
 
 ```tsx
 // React
-import { usePermissions } from '@symbiote-native/tracking-transparency/react';
+import { useTrackingPermissions } from '@symbiote-native/tracking-transparency/react';
 import { getAdvertisingId } from '@symbiote-native/tracking-transparency';
 
 function TrackingScreen() {
-  const [permissionStatus, requestPermission] = usePermissions();
+  const [permissionStatus, requestPermission] = useTrackingPermissions();
 
   return (
     <view>
@@ -118,11 +117,10 @@ function TrackingScreen() {
 ```vue
 <!-- Vue -->
 <script setup lang="ts">
-import { usePermissions } from '@symbiote-native/tracking-transparency/vue';
+import { useTrackingPermissions } from '@symbiote-native/tracking-transparency/vue';
 import { getAdvertisingId } from '@symbiote-native/tracking-transparency';
 
-const { status: permissionStatus, request: requestPermission } =
-  usePermissions();
+const [permissionStatus, requestPermission] = useTrackingPermissions();
 </script>
 
 <template>
@@ -142,7 +140,7 @@ const { status: permissionStatus, request: requestPermission } =
 // Angular
 import { Component, inject } from '@angular/core';
 import {
-  PermissionsService,
+  TrackingPermissionsService,
   getAdvertisingId,
 } from '@symbiote-native/tracking-transparency/angular';
 
@@ -162,7 +160,7 @@ import {
   `,
 })
 export class TrackingScreen {
-  protected readonly permissionsService = inject(PermissionsService);
+  protected readonly permissionsService = inject(TrackingPermissionsService);
   readonly permissionStatus = this.permissionsService.connect();
 
   logAdvertisingId(): void {
@@ -172,20 +170,20 @@ export class TrackingScreen {
 ```
 
 ```svelte
-<!-- Svelte — the rune hands back a boxed object whose `status` is a getter; destructuring it
+<!-- Svelte - the rune hands back a boxed object whose `status` is a getter; destructuring it
      would freeze the value at its initial null, since Svelte 5 reactivity is lexically scoped. -->
 <script lang="ts">
   import {
     getAdvertisingId,
-    usePermissions,
+    useTrackingPermissions,
   } from '@symbiote-native/tracking-transparency/svelte';
 
-  const permissions = usePermissions();
+  const permissions = useTrackingPermissions();
 </script>
 
 <view>
   <text>{permissions.status?.status ?? 'checking…'}</text>
-  <pressable onPress={() => permissions.request()}>
+  <pressable onPress={() => permissions.requestPermission()}>
     <text>Request tracking permission</text>
   </pressable>
   <pressable onPress={() => console.log(getAdvertisingId())}>
@@ -195,13 +193,12 @@ export class TrackingScreen {
 ```
 
 ```tsx
-// Solid — the accessors are CALLED; a Solid component body runs once, so a snapshot would freeze.
-import { createPermissions } from '@symbiote-native/tracking-transparency/solid';
+// Solid - the accessors are CALLED; a Solid component body runs once, so a snapshot would freeze.
+import { useTrackingPermissions } from '@symbiote-native/tracking-transparency/solid';
 import { getAdvertisingId } from '@symbiote-native/tracking-transparency';
 
 function TrackingScreen() {
-  const { status: permissionStatus, request: requestPermission } =
-    createPermissions();
+  const [permissionStatus, requestPermission] = useTrackingPermissions();
 
   return (
     <view>
@@ -217,7 +214,7 @@ function TrackingScreen() {
 }
 ```
 
-The examples above mirror the real canary demo screens —
+The examples above mirror the real canary demo screens:
 `examples/expo-react/screens/TrackingTransparencyScreen.tsx`,
 `examples/expo-vue-sfc/screens/TrackingTransparencyScreen.vue`,
 `examples/expo-vue-tsx/screens/TrackingTransparencyScreen.tsx`,
@@ -234,14 +231,14 @@ getAdvertisingId(): string | null
 
 getTrackingPermissionsAsync(): Promise<PermissionResponse>
 requestTrackingPermissionsAsync(): Promise<PermissionResponse>
-// On Android and web these always resolve granted — there is no tracking-consent concept there.
+// 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` —
+Plus `PermissionStatus`/`PermissionResponse`/`PermissionExpiration`/`PermissionHookOptions`:
 re-exported verbatim from `expo-modules-core`, never the `expo` meta-package.
 
 ```ts
@@ -252,57 +249,65 @@ import {
 
 // framework-scoped entry points re-export the same free functions, plus a per-adapter
 // permission wrapper:
-import { usePermissions } from '@symbiote-native/tracking-transparency/react';
-import { usePermissions } from '@symbiote-native/tracking-transparency/vue';
-import { usePermissions } from '@symbiote-native/tracking-transparency/svelte';
-import { createPermissions } from '@symbiote-native/tracking-transparency/solid';
-import { PermissionsService } from '@symbiote-native/tracking-transparency/angular';
+import { useTrackingPermissions } from '@symbiote-native/tracking-transparency/react';
+import { useTrackingPermissions } from '@symbiote-native/tracking-transparency/vue';
+import { useTrackingPermissions } from '@symbiote-native/tracking-transparency/svelte';
+import { useTrackingPermissions } from '@symbiote-native/tracking-transparency/solid';
+import { TrackingPermissionsService } from '@symbiote-native/tracking-transparency/angular';
 ```
 
-`usePermissions` auto-fetches the current permission status on mount and returns a
-`[status, request, get, error]` tuple (React) / `{ status, error, request, get }` object (Vue,
-destructurable — `status` is a `Ref`). Solid's `createPermissions` returns the same shape with
-`Accessor`s instead of `Ref`s, and Angular's `PermissionsService.connect()` returns a readonly
-`Signal`. **Svelte's rune returns a boxed object whose `status` is a getter — do not destructure
-it**, or the value freezes at its initial `null` (Svelte 5 reactivity is lexically scoped to the
-property access):
+`useTrackingPermissions` returns a `[status, request, get]` tuple: plain value (React), `Ref` (Vue),
+`Accessor` (Solid). Angular's `TrackingPermissionsService.connect()` returns a readonly `Signal`.
+**Svelte's rune returns a boxed object whose `status` is a getter - do not destructure it**, or
+the value freezes at its initial `null` (Svelte 5 reactivity is lexically scoped to the property
+access); its actions are `requestPermission()` and `getPermission()`:
 
 ```ts
 // React
-const [status, request] = usePermissions();
+const [status, request] = useTrackingPermissions();
 
 // Vue
-const { status, request } = usePermissions();
+const [status, request] = useTrackingPermissions();
 
-// Svelte — read permissions.status, never destructure it
-const permissions = usePermissions();
+// Svelte - read permissions.status, never destructure it
+const permissions = useTrackingPermissions();
 permissions.status;
 
-// Solid — status is an accessor, called at the read site
-const { status, request } = createPermissions();
+// Solid - status is an accessor, called at the read site
+const [status, request] = useTrackingPermissions();
 
 // Angular
-readonly status = inject(PermissionsService).connect();
+readonly status = inject(TrackingPermissionsService).connect();
 ```
 
 ## Platform notes
 
 - **Android and web always report granted.** There is no tracking-consent concept on either
-  platform — `getTrackingPermissionsAsync`/`requestTrackingPermissionsAsync` short-circuit to a
+  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
+- **`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.
 
+## Common questions
+
+- **Crash on request.** `NSUserTrackingUsageDescription` is missing from Info.plist.
+- **Dialog never appears.** Request only while the app state is `active`; guard duplicates.
+- **Rejection under Guideline 5.1.2.** Generic text is rejected; state a concrete user benefit.
+
+Sources: [Expo docs: TrackingTransparency](https://docs.expo.dev/versions/latest/sdk/tracking-transparency/),
+[expo/expo#13059](https://github.com/expo/expo/issues/13059),
+[Implement App Tracking Transparency with Expo](https://yosukep.medium.com/implement-app-tracking-transparency-with-expo-app-58cf77cb168d).
+
 ## Test it
 
-No Fabric/Descriptor angle at all — tracking-transparency is a pure async-function + permission
+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,svelte,solid,angular}/**/*.test.{ts,tsx}`,
-`vitest`), the same pattern `expo-tracking-transparency` itself uses upstream — no
+`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
 
-- Tests exercise the JS layer only (fake native module, `vitest`) — no on-device/simulator
+- 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

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

package/build/angular/index.js

@@ -1,4 +1,3 @@
-// PermissionsService is the Angular-only lifecycle half; getAdvertisingId/isAvailable are
-// stateless free functions, shared with React/Vue.
-export { PermissionsService } from './services/permissions.service/index.js';
+// @symbiote-native/tracking-transparency/angular: the core plus `TrackingPermissionsService`
+export { TrackingPermissionsService } from './tracking-permissions.service.js';
 export * from '../core/index.js';

package/build/angular/tracking-permissions.service.d.ts

@@ -0,0 +1,5 @@
+import { PermissionsServiceBase } from '@symbiote-native/angular';
+import type { PermissionResponse } from '../core';
+export declare class TrackingPermissionsService extends PermissionsServiceBase<PermissionResponse> {
+    constructor();
+}

package/build/angular/{services/permissions.service/index.js → tracking-permissions.service.js}

@@ -1,3 +1,4 @@
+// Angular twin of `../react`'s `useTrackingPermissions`: `inject(...).connect()` gives a signal
 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";
@@ -32,64 +33,28 @@ var __runInitializers = (this && this.__runInitializers) || function (thisArg, i
     }
     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 }}
-//
-// The auto-fetch has nobody to reject to, so its failure lands in the `error` signal instead of
-// escaping as an unhandled rejection: a null status with a non-null error is how a consumer tells
-// "the fetch failed" from "not fetched yet". get()/request() still reject to their direct caller —
-// only the automatic call is made safe.
-import { Injectable, signal } from '@angular/core';
-import { getTrackingPermissionsAsync, requestTrackingPermissionsAsync, } from '../../../core/index.js';
-let PermissionsService = (() => {
+import { Injectable } from '@angular/core';
+import { PermissionsServiceBase } from '@symbiote-native/angular';
+import { trackingPermissionMethods } from '../core/tracking-permission-api.js';
+let TrackingPermissionsService = (() => {
     let _classDecorators = [Injectable({ providedIn: 'root' })];
     let _classDescriptor;
     let _classExtraInitializers = [];
     let _classThis;
-    var PermissionsService = class {
+    let _classSuper = PermissionsServiceBase;
+    var TrackingPermissionsService = class extends _classSuper {
         static { _classThis = this; }
         static {
-            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
             __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
-            PermissionsService = _classThis = _classDescriptor.value;
+            TrackingPermissionsService = _classThis = _classDescriptor.value;
             if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
             __runInitializers(_classThis, _classExtraInitializers);
         }
-        status = signal(null);
-        fetchError = signal(null);
-        isAutoFetchStarted = false;
-        /** Why the auto-fetch left `status` at null. Cleared by the next successful get()/request(). */
-        error = this.fetchError.asReadonly();
-        connect() {
-            // Latched rather than guarded on `status() === null`: a failed fetch leaves status null
-            // forever, so the old guard turned every later connect() into another native call — unbounded
-            // once connect() is reached from a change-detected expression instead of a field initializer.
-            if (!this.isAutoFetchStarted) {
-                this.isAutoFetchStarted = true;
-                this.get().catch((cause) => {
-                    this.fetchError.set(cause instanceof Error ? cause : new Error(String(cause)));
-                });
-            }
-            return this.status.asReadonly();
-        }
-        async get() {
-            const response = await getTrackingPermissionsAsync();
-            this.status.set(response);
-            this.fetchError.set(null);
-            return response;
-        }
-        async request() {
-            const response = await requestTrackingPermissionsAsync();
-            this.status.set(response);
-            this.fetchError.set(null);
-            return response;
+        constructor() {
+            super(trackingPermissionMethods.getMethod, trackingPermissionMethods.requestMethod);
         }
     };
-    return PermissionsService = _classThis;
+    return TrackingPermissionsService = _classThis;
 })();
-export { PermissionsService };
+export { TrackingPermissionsService };

package/build/core/tracking-permission-api.d.ts

@@ -0,0 +1,5 @@
+import { getTrackingPermissionsAsync, requestTrackingPermissionsAsync } from './tracking-transparency';
+export declare const trackingPermissionMethods: {
+    getMethod: typeof getTrackingPermissionsAsync;
+    requestMethod: typeof requestTrackingPermissionsAsync;
+};

package/build/core/tracking-permission-api.js

@@ -0,0 +1,7 @@
+// `methods` every adapter's `useTrackingPermissions` binds to the shared
+// `@symbiote-native/{react,vue,solid,svelte}` `createPermissionHook` factory
+import { getTrackingPermissionsAsync, requestTrackingPermissionsAsync, } from './tracking-transparency.js';
+export const trackingPermissionMethods = {
+    getMethod: getTrackingPermissionsAsync,
+    requestMethod: requestTrackingPermissionsAsync,
+};

package/build/react/index.d.ts

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

package/build/react/index.js

@@ -1,6 +1,3 @@
-// @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/index.js';
+// @symbiote-native/tracking-transparency/react: the core plus `useTrackingPermissions`
+export { useTrackingPermissions, } from './use-tracking-permissions.js';
 export * from '../core/index.js';

package/build/react/use-tracking-permissions.d.ts

@@ -0,0 +1,8 @@
+import type { PermissionResponse } from '../core';
+import type { IPermissionHookBehavior } from '@symbiote-native/engine';
+export type IUseTrackingPermissionsHook = (options?: IPermissionHookBehavior) => [
+    PermissionResponse | null,
+    () => Promise<PermissionResponse>,
+    () => Promise<PermissionResponse>
+];
+export declare const useTrackingPermissions: IUseTrackingPermissionsHook;

package/build/react/use-tracking-permissions.js

@@ -0,0 +1,4 @@
+import { createPermissionHook } from '@symbiote-native/react';
+import { trackingPermissionMethods } from '../core/tracking-permission-api.js';
+// React twin of `expo-tracking-transparency`'s `useTrackingPermissions`
+export const useTrackingPermissions = createPermissionHook(trackingPermissionMethods);

package/build/solid/index.d.ts

@@ -1,2 +1,2 @@
-export { createPermissions } from './primitives/create-permissions';
+export { useTrackingPermissions, type IUseTrackingPermissionsHook, } from './use-tracking-permissions';
 export * from '../core';

package/build/solid/index.js

@@ -1,7 +1,3 @@
-// @symbiote-native/tracking-transparency/solid: the Solid entry over the framework-agnostic core.
-// Same reasoning as the React, Vue and Svelte entries — only the permission surface gets a
-// lifecycle primitive, every other export is a plain re-export — mirrors the lifecycle-bucket
-// naming convention of adapters/solid/src/primitives (never `hooks/`/`composables/`/`runes/`,
-// those are React's, Vue's and Svelte's terms).
-export { createPermissions } from './primitives/create-permissions.js';
+// @symbiote-native/tracking-transparency/solid: the core plus `useTrackingPermissions`
+export { useTrackingPermissions, } from './use-tracking-permissions.js';
 export * from '../core/index.js';

package/build/solid/use-tracking-permissions.d.ts

@@ -0,0 +1,9 @@
+import type { PermissionResponse } from '../core';
+import type { IPermissionHookBehavior } from '@symbiote-native/engine';
+import type { Accessor } from 'solid-js';
+export type IUseTrackingPermissionsHook = (options?: IPermissionHookBehavior) => [
+    Accessor<PermissionResponse | null>,
+    () => Promise<PermissionResponse>,
+    () => Promise<PermissionResponse>
+];
+export declare const useTrackingPermissions: IUseTrackingPermissionsHook;

package/build/solid/use-tracking-permissions.js

@@ -0,0 +1,4 @@
+import { createPermissionHook } from '@symbiote-native/solid';
+import { trackingPermissionMethods } from '../core/tracking-permission-api.js';
+// Solid twin of `../react`'s `useTrackingPermissions`
+export const useTrackingPermissions = createPermissionHook(trackingPermissionMethods);

package/build/svelte/index.d.ts

@@ -1,2 +1,2 @@
-export { usePermissions } from './runes/use-permissions.svelte';
+export { useTrackingPermissions, type IUseTrackingPermissionsHook, } from './use-tracking-permissions.svelte';
 export * from '../core';

package/build/svelte/index.js

@@ -1,6 +1,3 @@
-// @symbiote-native/tracking-transparency/svelte: the Svelte entry over the framework-agnostic core.
-// Same reasoning as the React and Vue entries — only the permission surface gets a lifecycle rune,
-// every other export is a plain re-export — mirrors the lifecycle-bucket naming convention of
-// adapters/svelte/src/runes (never `hooks/`/`composables/`, those are React's and Vue's terms).
-export { usePermissions } from './runes/use-permissions.svelte';
+// @symbiote-native/tracking-transparency/svelte: the core plus `useTrackingPermissions`
+export { useTrackingPermissions, } from './use-tracking-permissions.svelte';
 export * from '../core/index.js';

package/build/svelte/use-tracking-permissions.svelte.d.ts

@@ -0,0 +1,8 @@
+import type { PermissionResponse } from '../core';
+import type { IPermissionHookBehavior } from '@symbiote-native/engine';
+export type IUseTrackingPermissionsHook = (options?: IPermissionHookBehavior) => {
+    readonly status: PermissionResponse | null;
+    requestPermission: () => Promise<PermissionResponse>;
+    getPermission: () => Promise<PermissionResponse>;
+};
+export declare const useTrackingPermissions: IUseTrackingPermissionsHook;

package/build/svelte/use-tracking-permissions.svelte.js

@@ -0,0 +1,4 @@
+import { createPermissionHook } from '@symbiote-native/svelte/runes/create-permission-hook';
+import { trackingPermissionMethods } from '../core/tracking-permission-api.js';
+// Svelte twin of `../react`'s `useTrackingPermissions`
+export const useTrackingPermissions = createPermissionHook(trackingPermissionMethods);

package/build/vue/index.d.ts

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

package/build/vue/index.js

@@ -1,6 +1,3 @@
-// @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/index.js';
+// @symbiote-native/tracking-transparency/vue: the core plus `useTrackingPermissions`
+export { useTrackingPermissions, } from './use-tracking-permissions.js';
 export * from '../core/index.js';

package/build/vue/use-tracking-permissions.d.ts

@@ -0,0 +1,9 @@
+import type { PermissionResponse } from '../core';
+import type { IPermissionHookBehavior } from '@symbiote-native/engine';
+import type { Ref } from '@vue/runtime-core';
+export type IUseTrackingPermissionsHook = (options?: IPermissionHookBehavior) => [
+    Ref<PermissionResponse | null>,
+    () => Promise<PermissionResponse>,
+    () => Promise<PermissionResponse>
+];
+export declare const useTrackingPermissions: IUseTrackingPermissionsHook;

package/build/vue/use-tracking-permissions.js

@@ -0,0 +1,4 @@
+import { createPermissionHook } from '@symbiote-native/vue';
+import { trackingPermissionMethods } from '../core/tracking-permission-api.js';
+// Vue twin of `../react`'s `useTrackingPermissions`
+export const useTrackingPermissions = createPermissionHook(trackingPermissionMethods);

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

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

package/build-ngc/angular/index.js

@@ -1,5 +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';
+// @symbiote-native/tracking-transparency/angular: the core plus `TrackingPermissionsService`
+export { TrackingPermissionsService } from './tracking-permissions.service';
 export * from '../core';
 //# sourceMappingURL=index.js.map

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

@@ -1 +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"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/angular/index.ts"],"names":[],"mappings":"AAAA,6FAA6F;AAC7F,OAAO,EAAE,0BAA0B,EAAE,MAAM,gCAAgC,CAAC;AAC5E,cAAc,SAAS,CAAC"}

package/build-ngc/angular/tracking-permissions.service.d.ts

@@ -0,0 +1,8 @@
+import { PermissionsServiceBase } from '@symbiote-native/angular';
+import type { PermissionResponse } from '../core';
+import * as i0 from "@angular/core";
+export declare class TrackingPermissionsService extends PermissionsServiceBase<PermissionResponse> {
+    constructor();
+    static ɵfac: i0.ɵɵFactoryDeclaration<TrackingPermissionsService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<TrackingPermissionsService>;
+}

package/build-ngc/angular/tracking-permissions.service.js

@@ -0,0 +1,17 @@
+// Angular twin of `../react`'s `useTrackingPermissions`: `inject(...).connect()` gives a signal
+import { Injectable } from '@angular/core';
+import { PermissionsServiceBase } from '@symbiote-native/angular';
+import { trackingPermissionMethods } from '../core/tracking-permission-api';
+import * as i0 from "@angular/core";
+export class TrackingPermissionsService extends PermissionsServiceBase {
+    constructor() {
+        super(trackingPermissionMethods.getMethod, trackingPermissionMethods.requestMethod);
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: TrackingPermissionsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: TrackingPermissionsService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: TrackingPermissionsService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }], ctorParameters: () => [] });
+//# sourceMappingURL=tracking-permissions.service.js.map

package/build-ngc/angular/tracking-permissions.service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tracking-permissions.service.js","sourceRoot":"","sources":["../../src/angular/tracking-permissions.service.ts"],"names":[],"mappings":"AAAA,gGAAgG;AAEhG,OAAO,EAAE,UAAU,EAAE,MAAM,eAAe,CAAC;AAC3C,OAAO,EAAE,sBAAsB,EAAE,MAAM,0BAA0B,CAAC;AAClE,OAAO,EAAE,yBAAyB,EAAE,MAAM,iCAAiC,CAAC;;AAI5E,MAAM,OAAO,0BAA2B,SAAQ,sBAA0C;IACxF;QACE,KAAK,CACH,yBAAyB,CAAC,SAAS,EACnC,yBAAyB,CAAC,aAAa,CACxC,CAAC;IACJ,CAAC;uGANU,0BAA0B;2GAA1B,0BAA0B,cADb,MAAM;;2FACnB,0BAA0B;kBADtC,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE"}