@symbiote-native/tracking-transparency 3.0.2 → 3.1.0

package/src/react/hooks/use-permissions/index.ts

@@ -1,57 +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,
-  type PermissionResponse,
-} from '../../../core';
-
-export function usePermissions(): [
-  PermissionResponse | null,
-  () => Promise<PermissionResponse>,
-  () => Promise<PermissionResponse>,
-  Error | null,
-] {
-  const isMounted = useRef(true);
-  const [status, setStatus] = useState<PermissionResponse | null>(null);
-  const [error, setError] = useState<Error | null>(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: unknown) => {
-      if (isMounted.current)
-        setError(cause instanceof Error ? cause : new Error(String(cause)));
-    });
-    return () => {
-      isMounted.current = false;
-    };
-  }, [getPermission]);
-
-  return [status, requestPermission, getPermission, error];
-}

package/src/solid/primitives/create-permissions.ts

@@ -1,56 +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, type Accessor } from 'solid-js';
-import {
-  getTrackingPermissionsAsync,
-  requestTrackingPermissionsAsync,
-  type PermissionResponse,
-} from '../../core';
-
-export function createPermissions(): {
-  status: Accessor<PermissionResponse | null>;
-  error: Accessor<Error | null>;
-  request: () => Promise<PermissionResponse>;
-  get: () => Promise<PermissionResponse>;
-} {
-  const [status, setStatus] = createSignal<PermissionResponse | null>(null);
-  const [error, setError] = createSignal<Error | null>(null);
-
-  const get = async (): Promise<PermissionResponse> => {
-    const response = await getTrackingPermissionsAsync();
-    setStatus(response);
-    setError(null);
-    return response;
-  };
-
-  const request = async (): Promise<PermissionResponse> => {
-    const response = await requestTrackingPermissionsAsync();
-    setStatus(response);
-    setError(null);
-    return response;
-  };
-
-  get().catch((cause: unknown) => {
-    setError(cause instanceof Error ? cause : new Error(String(cause)));
-  });
-
-  return { status, error, request, get };
-}

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

@@ -1,63 +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,
-  type PermissionResponse,
-} from '../../core';
-
-export function usePermissions(): {
-  readonly status: PermissionResponse | null;
-  readonly error: Error | null;
-  request: () => Promise<PermissionResponse>;
-  get: () => Promise<PermissionResponse>;
-} {
-  let status = $state<PermissionResponse | null>(null);
-  let error = $state<Error | null>(null);
-
-  const get = async (): Promise<PermissionResponse> => {
-    const response = await getTrackingPermissionsAsync();
-    status = response;
-    error = null;
-    return response;
-  };
-
-  const request = async (): Promise<PermissionResponse> => {
-    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: unknown) => {
-      error = cause instanceof Error ? cause : new Error(String(cause));
-    });
-  });
-
-  return {
-    get status(): PermissionResponse | null {
-      return status;
-    },
-    get error(): Error | null {
-      return error;
-    },
-    request,
-    get,
-  };
-}

package/src/vue/composables/use-permissions/index.ts

@@ -1,47 +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, type Ref } from '@vue/runtime-core';
-import {
-  getTrackingPermissionsAsync,
-  requestTrackingPermissionsAsync,
-  type PermissionResponse,
-} from '../../../core';
-
-export function usePermissions(): {
-  status: Ref<PermissionResponse | null>;
-  error: Ref<Error | null>;
-  request: () => Promise<PermissionResponse>;
-  get: () => Promise<PermissionResponse>;
-} {
-  const status = ref<PermissionResponse | null>(null);
-  const error = ref<Error | null>(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: unknown) => {
-      error.value = cause instanceof Error ? cause : new Error(String(cause));
-    });
-  });
-
-  return { status, error, request, get };
-}