@symbiote-native/tracking-transparency 3.0.1 → 3.1.0

package/build-ngc/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-ngc/core/tracking-permission-api.js

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"tracking-permission-api.js","sourceRoot":"","sources":["../../src/core/tracking-permission-api.ts"],"names":[],"mappings":"AAAA,yEAAyE;AACzE,6EAA6E;AAE7E,OAAO,EACL,2BAA2B,EAC3B,+BAA+B,GAChC,MAAM,yBAAyB,CAAC;AAEjC,MAAM,CAAC,MAAM,yBAAyB,GAAG;IACvC,SAAS,EAAE,2BAA2B;IACtC,aAAa,EAAE,+BAA+B;CAC/C,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@symbiote-native/tracking-transparency",
-  "version": "3.0.1",
+  "version": "3.1.0",
   "description": "expo-tracking-transparency wrapped for SymbioteNative — one framework-agnostic core, built once and reachable from the React, Vue, Svelte, Solid, and Angular adapters. iOS App Tracking Transparency prompt (permission get/request, always-granted on Android/web) plus the advertising-ID getter.",
   "keywords": [
     "react-native",
@@ -69,7 +69,7 @@
   },
   "dependencies": {
     "expo-tracking-transparency": "57.0.1",
-    "expo-modules-core": "57.0.5"
+    "expo-modules-core": "57.0.20"
   },
   "peerDependencies": {
     "@angular/core": ">=20",
@@ -79,12 +79,12 @@
     "solid-js": ">=1.9.0",
     "svelte": ">=5.56.0",
     "vue": ">=3.5.0",
-    "@symbiote-native/angular": "^3.1.1",
-    "@symbiote-native/react": "^3.0.3",
-    "@symbiote-native/engine": "^1.3.0",
-    "@symbiote-native/svelte": "^3.0.3",
-    "@symbiote-native/vue": "^3.0.3",
-    "@symbiote-native/solid": "^3.0.3"
+    "@symbiote-native/engine": "^1.5.0",
+    "@symbiote-native/react": "^3.2.0",
+    "@symbiote-native/angular": "^3.2.0",
+    "@symbiote-native/vue": "^3.2.0",
+    "@symbiote-native/svelte": "^3.1.0",
+    "@symbiote-native/solid": "^3.1.0"
   },
   "peerDependenciesMeta": {
     "@symbiote-native/angular": {
@@ -132,13 +132,13 @@
     "solid-js": "^1.9.14",
     "svelte": "^5.56.0",
     "typescript": "~6.0.0",
-    "@symbiote-native/angular": "3.1.1",
-    "@symbiote-native/react": "3.0.3",
-    "@symbiote-native/engine": "1.3.0",
-    "@symbiote-native/svelte": "3.0.3",
-    "@symbiote-native/solid": "3.0.3",
-    "@symbiote-native/test-utils": "0.4.3",
-    "@symbiote-native/vue": "3.0.3"
+    "@symbiote-native/engine": "1.5.0",
+    "@symbiote-native/react": "3.2.0",
+    "@symbiote-native/svelte": "3.1.0",
+    "@symbiote-native/angular": "3.2.0",
+    "@symbiote-native/solid": "3.1.0",
+    "@symbiote-native/test-utils": "0.4.6",
+    "@symbiote-native/vue": "3.2.0"
   },
   "scripts": {
     "typecheck": "tsc --build",

package/src/angular/index.ts

@@ -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';
+// @symbiote-native/tracking-transparency/angular: the core plus `TrackingPermissionsService`
+export { TrackingPermissionsService } from './tracking-permissions.service';
 export * from '../core';

package/src/angular/tracking-permissions.service.ts

@@ -0,0 +1,16 @@
+// 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 type { PermissionResponse } from '../core';
+
+@Injectable({ providedIn: 'root' })
+export class TrackingPermissionsService extends PermissionsServiceBase<PermissionResponse> {
+  constructor() {
+    super(
+      trackingPermissionMethods.getMethod,
+      trackingPermissionMethods.requestMethod,
+    );
+  }
+}

package/src/core/tracking-permission-api.ts

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

package/src/react/index.ts

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

package/src/react/use-tracking-permissions.ts

@@ -0,0 +1,16 @@
+import { createPermissionHook } from '@symbiote-native/react';
+import { trackingPermissionMethods } from '../core/tracking-permission-api';
+import type { PermissionResponse } from '../core';
+import type { IPermissionHookBehavior } from '@symbiote-native/engine';
+
+export type IUseTrackingPermissionsHook = (
+  options?: IPermissionHookBehavior,
+) => [
+  PermissionResponse | null,
+  () => Promise<PermissionResponse>,
+  () => Promise<PermissionResponse>,
+];
+
+// React twin of `expo-tracking-transparency`'s `useTrackingPermissions`
+export const useTrackingPermissions: IUseTrackingPermissionsHook =
+  createPermissionHook(trackingPermissionMethods);

package/src/solid/index.ts

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

package/src/solid/use-tracking-permissions.ts

@@ -0,0 +1,17 @@
+import { createPermissionHook } from '@symbiote-native/solid';
+import { trackingPermissionMethods } from '../core/tracking-permission-api';
+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>,
+];
+
+// Solid twin of `../react`'s `useTrackingPermissions`
+export const useTrackingPermissions: IUseTrackingPermissionsHook =
+  createPermissionHook(trackingPermissionMethods);

package/src/svelte/index.ts

@@ -1,7 +1,6 @@
-// @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,
+  type IUseTrackingPermissionsHook,
+} from './use-tracking-permissions.svelte';
 export * from '../core';

package/src/svelte/svelte-compile.test-helper.ts

@@ -0,0 +1,6 @@
+// Re-exports the existing harness instead of another copy
+export {
+  createSvelteHarness,
+  loadComponent,
+  type ISvelteHarness,
+} from '../../../sqlite/src/svelte/svelte-compile.test-helper';

package/src/svelte/use-tracking-permissions.svelte.ts

@@ -0,0 +1,16 @@
+import { createPermissionHook } from '@symbiote-native/svelte/runes/create-permission-hook';
+import { trackingPermissionMethods } from '../core/tracking-permission-api';
+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>;
+};
+
+// Svelte twin of `../react`'s `useTrackingPermissions`
+export const useTrackingPermissions: IUseTrackingPermissionsHook =
+  createPermissionHook(trackingPermissionMethods);

package/src/vue/index.ts

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

package/src/vue/use-tracking-permissions.ts

@@ -0,0 +1,17 @@
+import { createPermissionHook } from '@symbiote-native/vue';
+import { trackingPermissionMethods } from '../core/tracking-permission-api';
+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>,
+];
+
+// Vue twin of `../react`'s `useTrackingPermissions`
+export const useTrackingPermissions: IUseTrackingPermissionsHook =
+  createPermissionHook(trackingPermissionMethods);

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

@@ -1,12 +0,0 @@
-import { type Signal } from '@angular/core';
-import { type PermissionResponse } from '../../../core';
-export declare class PermissionsService {
-    private readonly status;
-    private readonly fetchError;
-    private isAutoFetchStarted;
-    /** Why the auto-fetch left `status` at null. Cleared by the next successful get()/request(). */
-    readonly error: Signal<Error | null>;
-    connect(): Signal<PermissionResponse | null>;
-    get(): Promise<PermissionResponse>;
-    request(): Promise<PermissionResponse>;
-}

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

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

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

@@ -1,43 +0,0 @@
-// 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.
-//
-// The mount fetch has nobody to reject to, so its failure lands in the 4th tuple slot (`error`)
-// 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 { useCallback, useEffect, useRef, useState } from 'react';
-import { getTrackingPermissionsAsync, requestTrackingPermissionsAsync, } from '../../../core/index.js';
-export function usePermissions() {
-    const isMounted = useRef(true);
-    const [status, setStatus] = useState(null);
-    const [error, setError] = useState(null);
-    const getPermission = useCallback(async () => {
-        const response = await getTrackingPermissionsAsync();
-        if (isMounted.current) {
-            setStatus(response);
-            setError(null);
-        }
-        return response;
-    }, []);
-    const requestPermission = useCallback(async () => {
-        const response = await requestTrackingPermissionsAsync();
-        if (isMounted.current) {
-            setStatus(response);
-            setError(null);
-        }
-        return response;
-    }, []);
-    useEffect(() => {
-        isMounted.current = true;
-        getPermission().catch((cause) => {
-            if (isMounted.current)
-                setError(cause instanceof Error ? cause : new Error(String(cause)));
-        });
-        return () => {
-            isMounted.current = false;
-        };
-    }, [getPermission]);
-    return [status, requestPermission, getPermission, error];
-}

package/build/solid/primitives/create-permissions.d.ts

@@ -1,8 +0,0 @@
-import { type Accessor } from 'solid-js';
-import { type PermissionResponse } from '../../core';
-export declare function createPermissions(): {
-    status: Accessor<PermissionResponse | null>;
-    error: Accessor<Error | null>;
-    request: () => Promise<PermissionResponse>;
-    get: () => Promise<PermissionResponse>;
-};

package/build/solid/primitives/create-permissions.js

@@ -1,41 +0,0 @@
-// createPermissions — the Solid twin of React's `usePermissions` hook, Vue's composable and
-// Svelte's rune, over the framework-agnostic core (core/tracking-transparency.ts). Auto-fetches
-// the current permission status, then exposes get/request as imperative callbacks.
-//
-// `primitives/` and `create*`, never `hooks/`+`use*`: Solid's ecosystem calls a composable
-// reactive function a PRIMITIVE and reserves `use*` for consuming something that already exists.
-// Full rationale in adapters/solid/src/primitives/create-color-scheme.ts.
-//
-// Returns ACCESSORS, never snapshots: a Solid component body runs ONCE, so returned values would
-// pin the caller to the null pre-fetch state forever.
-//
-// The auto-fetch fires from the primitive body rather than a mount effect — the shape
-// `createResource` uses, and the reason this primitive needs no lifecycle hook at all. Its failure
-// lands in `error` 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.
-//
-// No isMounted guard around the late write, unlike React's hook: once the owning root is disposed
-// nothing is subscribed to these signals any more, so a resolution arriving afterwards is inert.
-import { createSignal } from 'solid-js';
-import { getTrackingPermissionsAsync, requestTrackingPermissionsAsync, } from '../../core/index.js';
-export function createPermissions() {
-    const [status, setStatus] = createSignal(null);
-    const [error, setError] = createSignal(null);
-    const get = async () => {
-        const response = await getTrackingPermissionsAsync();
-        setStatus(response);
-        setError(null);
-        return response;
-    };
-    const request = async () => {
-        const response = await requestTrackingPermissionsAsync();
-        setStatus(response);
-        setError(null);
-        return response;
-    };
-    get().catch((cause) => {
-        setError(cause instanceof Error ? cause : new Error(String(cause)));
-    });
-    return { status, error, request, get };
-}

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

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

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

@@ -1,49 +0,0 @@
-// Svelte 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. Just a one-shot get with no ongoing subscription, so `$effect` needs no cleanup.
-//
-// `.svelte.ts` (not `.ts`): runes ($state/$effect) only work in files with this extension
-// outside an actual `.svelte` component. `status` is returned as a getter, NOT a bare
-// `$state`: Svelte 5 reactivity is lexically scoped to the declaring module and doesn't
-// survive being returned as a raw value from a plain function — mirrors how Vue's `Ref`
-// needs `.value` to unwrap.
-//
-// The mount fetch has nobody to reject to, so its failure lands in `error` (a second boxed getter,
-// same reason as `status`) 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 { getTrackingPermissionsAsync, requestTrackingPermissionsAsync, } from '../../core/index.js';
-export function usePermissions() {
-    let status = $state(null);
-    let error = $state(null);
-    const get = async () => {
-        const response = await getTrackingPermissionsAsync();
-        status = response;
-        error = null;
-        return response;
-    };
-    const request = async () => {
-        const response = await requestTrackingPermissionsAsync();
-        status = response;
-        error = null;
-        return response;
-    };
-    $effect(() => {
-        // `get` is a plain closure, not reactive state, so the effect has an empty dependency set and
-        // runs exactly once on mount — the twin of Vue's onMounted. The catch runs after the effect
-        // has settled, so writing `error` there adds no dependency and does not re-arm it.
-        get().catch((cause) => {
-            error = cause instanceof Error ? cause : new Error(String(cause));
-        });
-    });
-    return {
-        get status() {
-            return status;
-        },
-        get error() {
-            return error;
-        },
-        request,
-        get,
-    };
-}

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

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

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

@@ -1,33 +0,0 @@
-// 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.
-//
-// The mount fetch has nobody to reject to, so its failure lands in the `error` ref 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 { onMounted, ref } from '@vue/runtime-core';
-import { getTrackingPermissionsAsync, requestTrackingPermissionsAsync, } from '../../../core/index.js';
-export function usePermissions() {
-    const status = ref(null);
-    const error = ref(null);
-    const get = async () => {
-        const response = await getTrackingPermissionsAsync();
-        status.value = response;
-        error.value = null;
-        return response;
-    };
-    const request = async () => {
-        const response = await requestTrackingPermissionsAsync();
-        status.value = response;
-        error.value = null;
-        return response;
-    };
-    onMounted(() => {
-        get().catch((cause) => {
-            error.value = cause instanceof Error ? cause : new Error(String(cause));
-        });
-    });
-    return { status, error, request, get };
-}

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

@@ -1,15 +0,0 @@
-import { type Signal } from '@angular/core';
-import { type PermissionResponse } from '../../../core';
-import * as i0 from "@angular/core";
-export declare class PermissionsService {
-    private readonly status;
-    private readonly fetchError;
-    private isAutoFetchStarted;
-    /** Why the auto-fetch left `status` at null. Cleared by the next successful get()/request(). */
-    readonly error: Signal<Error | null>;
-    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

@@ -1,55 +0,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';
-import * as i0 from "@angular/core";
-export class PermissionsService {
-    status = signal(null, /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "status" }] : /* istanbul ignore next */ []));
-    fetchError = signal(null, /* @ts-ignore */
-    ...(ngDevMode ? [{ debugName: "fetchError" }] : /* istanbul ignore next */ []));
-    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;
-    }
-    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: PermissionsService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
-    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: PermissionsService, providedIn: 'root' });
-}
-i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.8", ngImport: i0, type: PermissionsService, decorators: [{
-            type: Injectable,
-            args: [{ providedIn: 'root' }]
-        }] });
-//# sourceMappingURL=index.js.map

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

@@ -1 +0,0 @@
-{"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,EAAE;AACF,gGAAgG;AAChG,kGAAkG;AAClG,mGAAmG;AACnG,wCAAwC;AACxC,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;IACjD,UAAU,GAAG,MAAM,CAAe,IAAI;mFAAC,CAAC;IACjD,kBAAkB,GAAG,KAAK,CAAC;IAEnC,gGAAgG;IACvF,KAAK,GAAyB,IAAI,CAAC,UAAU,CAAC,UAAU,EAAE,CAAC;IAEpE,OAAO;QACL,wFAAwF;QACxF,8FAA8F;QAC9F,8FAA8F;QAC9F,IAAI,CAAC,IAAI,CAAC,kBAAkB,EAAE,CAAC;YAC7B,IAAI,CAAC,kBAAkB,GAAG,IAAI,CAAC;YAC/B,IAAI,CAAC,GAAG,EAAE,CAAC,KAAK,CAAC,CAAC,KAAc,EAAE,EAAE;gBAClC,IAAI,CAAC,UAAU,CAAC,GAAG,CACjB,KAAK,YAAY,KAAK,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,IAAI,KAAK,CAAC,MAAM,CAAC,KAAK,CAAC,CAAC,CAC1D,CAAC;YACJ,CAAC,CAAC,CAAC;QACL,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,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,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,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,IAAI,CAAC,CAAC;QAC1B,OAAO,QAAQ,CAAC;IAClB,CAAC;uGAnCU,kBAAkB;2GAAlB,kBAAkB,cADL,MAAM;;2FACnB,kBAAkB;kBAD9B,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE"}

package/src/angular/services/permissions.service/index.ts

@@ -1,57 +0,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, type Signal } from '@angular/core';
-import {
-  getTrackingPermissionsAsync,
-  requestTrackingPermissionsAsync,
-  type PermissionResponse,
-} from '../../../core';
-
-@Injectable({ providedIn: 'root' })
-export class PermissionsService {
-  private readonly status = signal<PermissionResponse | null>(null);
-  private readonly fetchError = signal<Error | null>(null);
-  private isAutoFetchStarted = false;
-
-  /** Why the auto-fetch left `status` at null. Cleared by the next successful get()/request(). */
-  readonly error: Signal<Error | null> = this.fetchError.asReadonly();
-
-  connect(): Signal<PermissionResponse | null> {
-    // 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: unknown) => {
-        this.fetchError.set(
-          cause instanceof Error ? cause : new Error(String(cause)),
-        );
-      });
-    }
-    return this.status.asReadonly();
-  }
-
-  async get(): Promise<PermissionResponse> {
-    const response = await getTrackingPermissionsAsync();
-    this.status.set(response);
-    this.fetchError.set(null);
-    return response;
-  }
-
-  async request(): Promise<PermissionResponse> {
-    const response = await requestTrackingPermissionsAsync();
-    this.status.set(response);
-    this.fetchError.set(null);
-    return response;
-  }
-}