@ng-native/expo 0.0.1 → 0.1.0

package/dist/permissions.js

@@ -0,0 +1,72 @@
+/**
+ * A permission, as signals rather than a hook.
+ *
+ * Every Expo module that needs one exposes the same shape: `getXPermissionsAsync`,
+ * `requestXPermissionsAsync`, and a `useXPermissions()` hook that is those two plus React state.
+ * So this is not a facade per module - it is one class that takes the pair, and the module stays
+ * the app's own dependency:
+ *
+ * ```ts
+ * import * as Camera from 'expo-camera';
+ * import { Permission } from '@ng-native/expo';
+ *
+ * readonly camera = Permission.of(Camera.Camera.getCameraPermissionsAsync,
+ *                                 Camera.Camera.requestCameraPermissionsAsync);
+ * ```
+ */
+import { computed, signal } from '@angular/core';
+export class Permission {
+    api;
+    last = signal(null, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "last" }] : /* istanbul ignore next */ []));
+    constructor(api) {
+        this.api = api;
+    }
+    /** `unknown` until something has asked the platform, which is not the same as `undetermined`. */
+    status = computed(() => this.last()?.status ?? 'unknown', /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "status" }] : /* istanbul ignore next */ []));
+    granted = computed(() => this.last()?.granted ?? false, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "granted" }] : /* istanbul ignore next */ []));
+    /** Refused, and the platform will not show a dialog again. Send them to Settings. */
+    blocked = computed(() => {
+        const response = this.last();
+        return response !== null && !response.granted && !response.canAskAgain;
+    }, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "blocked" }] : /* istanbul ignore next */ []));
+    /** From a module's own two functions, which is how every one of them spells this. */
+    static of(get, request) {
+        return new Permission({ get, request });
+    }
+    /** Ask the platform what it currently thinks, without showing anything to the user. */
+    async check() {
+        return this.record(await this.api.get());
+    }
+    /** Show the dialog. Resolves to what the user said. */
+    async request() {
+        return this.record(await this.api.request());
+    }
+    /**
+     * Have the permission if it can be had, asking only if asking would do something.
+     *
+     * The method most call sites want. A permission already granted needs no dialog, and one the
+     * platform has stopped asking about would return the same no while looking like the user had
+     * been consulted.
+     */
+    async ensure() {
+        if (this.last() === null)
+            await this.check();
+        const current = this.last();
+        if (current?.granted)
+            return true;
+        // Refused for good. Requesting again resolves to the same no without the platform showing
+        // anything, which reads at the call site as though the user had been asked twice.
+        if (current && !current.canAskAgain)
+            return false;
+        return this.request();
+    }
+    record(response) {
+        this.last.set(response);
+        return response.granted;
+    }
+}
+//# sourceMappingURL=permissions.js.map

package/dist/permissions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"permissions.js","sourceRoot":"","sources":["../src/permissions.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAE,QAAQ,EAAE,MAAM,EAAe,MAAM,eAAe,CAAC;AAgB9D,MAAM,OAAO,UAAU;IACJ,GAAG,CAAgB;IACnB,IAAI,GAAG,MAAM,CAA4B,IAAI;6EAAC,CAAC;IAEhE,YAAY,GAAkB;QAC5B,IAAI,CAAC,GAAG,GAAG,GAAG,CAAC;IACjB,CAAC;IAED,iGAAiG;IACxF,MAAM,GAAqD,QAAQ,CAC1E,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,MAAM,IAAI,SAAS;+EACvC,CAAC;IAEO,OAAO,GAAoB,QAAQ,CAAC,GAAG,EAAE,CAAC,IAAI,CAAC,IAAI,EAAE,EAAE,OAAO,IAAI,KAAK;gFAAC,CAAC;IAElF,qFAAqF;IAC5E,OAAO,GAAoB,QAAQ,CAAC,GAAG,EAAE;QAChD,MAAM,QAAQ,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;QAC7B,OAAO,QAAQ,KAAK,IAAI,IAAI,CAAC,QAAQ,CAAC,OAAO,IAAI,CAAC,QAAQ,CAAC,WAAW,CAAC;IACzE,CAAC;gFAAC,CAAC;IAEH,qFAAqF;IACrF,MAAM,CAAC,EAAE,CACP,GAAsC,EACtC,OAA0C;QAE1C,OAAO,IAAI,UAAU,CAAC,EAAE,GAAG,EAAE,OAAO,EAAE,CAAC,CAAC;IAC1C,CAAC;IAED,uFAAuF;IACvF,KAAK,CAAC,KAAK;QACT,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,IAAI,CAAC,GAAG,CAAC,GAAG,EAAE,CAAC,CAAC;IAC3C,CAAC;IAED,uDAAuD;IACvD,KAAK,CAAC,OAAO;QACX,OAAO,IAAI,CAAC,MAAM,CAAC,MAAM,IAAI,CAAC,GAAG,CAAC,OAAO,EAAE,CAAC,CAAC;IAC/C,CAAC;IAED;;;;;;OAMG;IACH,KAAK,CAAC,MAAM;QACV,IAAI,IAAI,CAAC,IAAI,EAAE,KAAK,IAAI;YAAE,MAAM,IAAI,CAAC,KAAK,EAAE,CAAC;QAE7C,MAAM,OAAO,GAAG,IAAI,CAAC,IAAI,EAAE,CAAC;QAC5B,IAAI,OAAO,EAAE,OAAO;YAAE,OAAO,IAAI,CAAC;QAClC,0FAA0F;QAC1F,kFAAkF;QAClF,IAAI,OAAO,IAAI,CAAC,OAAO,CAAC,WAAW;YAAE,OAAO,KAAK,CAAC;QAClD,OAAO,IAAI,CAAC,OAAO,EAAE,CAAC;IACxB,CAAC;IAEO,MAAM,CAAC,QAA4B;QACzC,IAAI,CAAC,IAAI,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC;QACxB,OAAO,QAAQ,CAAC,OAAO,CAAC;IAC1B,CAAC;CACF","sourcesContent":["/**\n * A permission, as signals rather than a hook.\n *\n * Every Expo module that needs one exposes the same shape: `getXPermissionsAsync`,\n * `requestXPermissionsAsync`, and a `useXPermissions()` hook that is those two plus React state.\n * So this is not a facade per module - it is one class that takes the pair, and the module stays\n * the app's own dependency:\n *\n * ```ts\n * import * as Camera from 'expo-camera';\n * import { Permission } from '@ng-native/expo';\n *\n * readonly camera = Permission.of(Camera.Camera.getCameraPermissionsAsync,\n *                                 Camera.Camera.requestCameraPermissionsAsync);\n * ```\n */\nimport { computed, signal, type Signal } from '@angular/core';\n\n/** What every Expo permission call answers with. */\nexport interface PermissionResponse {\n  readonly status: 'granted' | 'denied' | 'undetermined';\n  readonly granted: boolean;\n  /** False once the platform will no longer show a dialog: the app must send them to Settings. */\n  readonly canAskAgain: boolean;\n}\n\n/** The pair of functions a module exposes, which its hook is built out of. */\nexport interface PermissionApi {\n  get(): Promise<PermissionResponse>;\n  request(): Promise<PermissionResponse>;\n}\n\nexport class Permission {\n  private readonly api: PermissionApi;\n  private readonly last = signal<PermissionResponse | null>(null);\n\n  constructor(api: PermissionApi) {\n    this.api = api;\n  }\n\n  /** `unknown` until something has asked the platform, which is not the same as `undetermined`. */\n  readonly status: Signal<PermissionResponse['status'] | 'unknown'> = computed(\n    () => this.last()?.status ?? 'unknown',\n  );\n\n  readonly granted: Signal<boolean> = computed(() => this.last()?.granted ?? false);\n\n  /** Refused, and the platform will not show a dialog again. Send them to Settings. */\n  readonly blocked: Signal<boolean> = computed(() => {\n    const response = this.last();\n    return response !== null && !response.granted && !response.canAskAgain;\n  });\n\n  /** From a module's own two functions, which is how every one of them spells this. */\n  static of(\n    get: () => Promise<PermissionResponse>,\n    request: () => Promise<PermissionResponse>,\n  ): Permission {\n    return new Permission({ get, request });\n  }\n\n  /** Ask the platform what it currently thinks, without showing anything to the user. */\n  async check(): Promise<boolean> {\n    return this.record(await this.api.get());\n  }\n\n  /** Show the dialog. Resolves to what the user said. */\n  async request(): Promise<boolean> {\n    return this.record(await this.api.request());\n  }\n\n  /**\n   * Have the permission if it can be had, asking only if asking would do something.\n   *\n   * The method most call sites want. A permission already granted needs no dialog, and one the\n   * platform has stopped asking about would return the same no while looking like the user had\n   * been consulted.\n   */\n  async ensure(): Promise<boolean> {\n    if (this.last() === null) await this.check();\n\n    const current = this.last();\n    if (current?.granted) return true;\n    // Refused for good. Requesting again resolves to the same no without the platform showing\n    // anything, which reads at the call site as though the user had been asked twice.\n    if (current && !current.canAskAgain) return false;\n    return this.request();\n  }\n\n  private record(response: PermissionResponse): boolean {\n    this.last.set(response);\n    return response.granted;\n  }\n}\n"]}

package/dist/player.d.ts

@@ -0,0 +1,92 @@
+/**
+ * Media players, bound to `expo-video` and `expo-audio`.
+ *
+ * ```ts
+ * protected readonly player = videoPlayer(this.source, { timeUpdate: 0.5 });
+ *
+ * // <expo-video [player]="player.native" />
+ * // {{ player.state().currentTime }}
+ * ```
+ *
+ * `useVideoPlayer` and `useAudioPlayer` are the documented way in, and the player they hand back
+ * is not the React part - `createVideoPlayer` gives the same object. What the hooks add is the
+ * two things a component actually needs and cannot get otherwise: the player is *released* when
+ * the component goes, and its changing state is *readable*, because the player's own properties
+ * are plain mutable fields that no template can watch.
+ *
+ * The player itself is passed straight through: it is a shared object with `play()`, `seekBy()`
+ * and the rest already on it, and wrapping those would be a second place for each to be wrong.
+ */
+import { type Signal } from '@angular/core';
+/** The player's own status, which is the same word in both modules. */
+export type PlayerStatus = 'idle' | 'loading' | 'readyToPlay' | 'error';
+/** The slice of a player this reads. Both modules' players satisfy it structurally. */
+export interface NativePlayer {
+    addListener(event: string, listener: (payload: never) => void): {
+        remove(): void;
+    };
+    release?(): void;
+    /** Seconds between `timeUpdate` events. Zero, its default, means the event never fires. `expo-video` only. */
+    timeUpdateEventInterval?: number;
+    /** Read directly rather than from an event: `expo-audio`'s status carries no volume field. */
+    readonly volume?: number;
+}
+/**
+ * `expo-audio`'s one status event, `playbackStatusUpdate`. Unlike `expo-video`, which splits its
+ * state across several named events, `AudioPlayer` reports everything - including errors - on a
+ * single event, at the interval `updateInterval` was created with.
+ */
+export interface NativeAudioStatus {
+    readonly playing: boolean;
+    readonly mute: boolean;
+    readonly duration: number;
+    readonly currentTime: number;
+    readonly isLoaded: boolean;
+    readonly didJustFinish: boolean;
+    readonly error: string | null;
+}
+export interface PlayerState {
+    readonly playing: boolean;
+    readonly status: PlayerStatus;
+    /** Seconds. Only moves while `timeUpdateEventInterval` is non-zero. */
+    readonly currentTime: number;
+    readonly duration: number;
+    readonly muted: boolean;
+    readonly volume: number;
+    /** Set once playback has run to the end, and cleared when it starts again. */
+    readonly ended: boolean;
+}
+/**
+ * Watch an `expo-video` player, and stop watching when the caller is done with it.
+ *
+ * `timeUpdate` defaults to off, so `currentTime` would never move. A caller that wants a progress
+ * bar asks for one by passing an interval, and one that does not pays nothing: the event is the
+ * most frequent thing the player emits.
+ *
+ * `expo-audio`'s player reports its state differently - one event, not several - so it is watched
+ * by `watchAudioPlayer` below rather than this function.
+ */
+export declare function watchPlayer(player: NativePlayer | null, options?: {
+    timeUpdate?: number;
+}): {
+    state: Signal<PlayerState>;
+    stop: () => void;
+};
+export interface Player<T> {
+    /** The module's own player, for `play()`, `seekBy()`, and to hand to its view. */
+    readonly native: T;
+    readonly state: Signal<PlayerState>;
+}
+/** A video player owned by the current component, released when it is destroyed. */
+export declare function videoPlayer(source: import('expo-video').VideoSource, options?: {
+    timeUpdate?: number;
+}): Player<import('expo-video').VideoPlayer>;
+/**
+ * An audio player owned by the current component, released when it is destroyed.
+ *
+ * `expo-audio` has no `timeUpdateEventInterval` property to set after the fact - the interval is
+ * an option to `createAudioPlayer` itself, in milliseconds rather than `videoPlayer`'s seconds.
+ */
+export declare function audioPlayer(source: import('expo-audio').AudioSource, options?: {
+    timeUpdate?: number;
+}): Player<import('expo-audio').AudioPlayer>;

package/dist/player.js

@@ -0,0 +1,141 @@
+/**
+ * Media players, bound to `expo-video` and `expo-audio`.
+ *
+ * ```ts
+ * protected readonly player = videoPlayer(this.source, { timeUpdate: 0.5 });
+ *
+ * // <expo-video [player]="player.native" />
+ * // {{ player.state().currentTime }}
+ * ```
+ *
+ * `useVideoPlayer` and `useAudioPlayer` are the documented way in, and the player they hand back
+ * is not the React part - `createVideoPlayer` gives the same object. What the hooks add is the
+ * two things a component actually needs and cannot get otherwise: the player is *released* when
+ * the component goes, and its changing state is *readable*, because the player's own properties
+ * are plain mutable fields that no template can watch.
+ *
+ * The player itself is passed straight through: it is a shared object with `play()`, `seekBy()`
+ * and the rest already on it, and wrapping those would be a second place for each to be wrong.
+ */
+import { DestroyRef, inject, signal } from '@angular/core';
+import { expoModule } from "./native.js";
+const INITIAL = {
+    playing: false,
+    status: 'idle',
+    currentTime: 0,
+    duration: 0,
+    muted: false,
+    volume: 1,
+    ended: false,
+};
+/**
+ * Watch an `expo-video` player, and stop watching when the caller is done with it.
+ *
+ * `timeUpdate` defaults to off, so `currentTime` would never move. A caller that wants a progress
+ * bar asks for one by passing an interval, and one that does not pays nothing: the event is the
+ * most frequent thing the player emits.
+ *
+ * `expo-audio`'s player reports its state differently - one event, not several - so it is watched
+ * by `watchAudioPlayer` below rather than this function.
+ */
+export function watchPlayer(player, options = {}) {
+    const state = signal(INITIAL, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "state" }] : /* istanbul ignore next */ []));
+    if (!player)
+        return { state: state.asReadonly(), stop: () => { } };
+    const patch = (change) => state.update((last) => ({ ...last, ...change }));
+    const subscriptions = [
+        listen(player, 'statusChange', ({ status }) => patch({ status })),
+        listen(player, 'playingChange', ({ isPlaying }) => patch({ playing: isPlaying, ...(isPlaying ? { ended: false } : {}) })),
+        listen(player, 'mutedChange', ({ muted }) => patch({ muted })),
+        listen(player, 'volumeChange', ({ volume }) => patch({ volume })),
+        listen(player, 'playToEnd', () => patch({ ended: true, playing: false })),
+        listen(player, 'timeUpdate', ({ currentTime }) => patch({ currentTime })),
+        listen(player, 'sourceChange', () => patch({ ...INITIAL, status: 'loading' })),
+        // The only event that says how long the video is: nothing else carries a duration.
+        listen(player, 'sourceLoad', ({ duration }) => patch({ duration })),
+    ];
+    if (options.timeUpdate !== undefined)
+        player.timeUpdateEventInterval = options.timeUpdate;
+    return {
+        state: state.asReadonly(),
+        stop: () => {
+            for (const subscription of subscriptions)
+                subscription();
+            // Releasing is the half a hook does that nothing else will: a player left alive holds its
+            // decoder, its audio session and, on iOS, the now-playing controls.
+            player.release?.();
+        },
+    };
+}
+function listen(player, event, handler) {
+    const subscription = player.addListener(event, handler);
+    return () => subscription.remove();
+}
+/**
+ * Watch an `expo-audio` player, and stop watching when the caller is done with it.
+ *
+ * `AudioPlayer` reports its whole state on `playbackStatusUpdate`, at the interval it was created
+ * with, rather than splitting it across the several events `expo-video` uses - so unlike
+ * `watchPlayer`, there is one listener, not several, and nothing to reset on a source change: the
+ * next status update carries the new source's own state.
+ */
+function watchAudioPlayer(player) {
+    const state = signal(INITIAL, /* @ts-ignore */
+    ...(ngDevMode ? [{ debugName: "state" }] : /* istanbul ignore next */ []));
+    if (!player)
+        return { state: state.asReadonly(), stop: () => { } };
+    const subscription = listen(player, 'playbackStatusUpdate', (status) => state.set({
+        playing: status.playing,
+        status: status.error !== null ? 'error' : status.isLoaded ? 'readyToPlay' : 'loading',
+        currentTime: status.currentTime,
+        duration: status.duration,
+        muted: status.mute,
+        // Not on the status event; the player's own property is the current value.
+        volume: player.volume ?? INITIAL.volume,
+        ended: status.didJustFinish,
+    }));
+    return {
+        state: state.asReadonly(),
+        stop: () => {
+            subscription();
+            // Releasing is the half a hook does that nothing else will: a player left alive holds its
+            // decoder, its audio session and, on iOS, the now-playing controls.
+            player.release?.();
+        },
+    };
+}
+/** A video player owned by the current component, released when it is destroyed. */
+export function videoPlayer(source, options = {}) {
+    const expo = expoModule('expo-video', () => require('expo-video'), ['ios', 'android', 'web']);
+    if (!expo)
+        throw new Error('[angular-native] expo-video is not installed');
+    const native = expo.createVideoPlayer(source);
+    return own(native, () => watchPlayer(native, options));
+}
+/**
+ * An audio player owned by the current component, released when it is destroyed.
+ *
+ * `expo-audio` has no `timeUpdateEventInterval` property to set after the fact - the interval is
+ * an option to `createAudioPlayer` itself, in milliseconds rather than `videoPlayer`'s seconds.
+ */
+export function audioPlayer(source, options = {}) {
+    const expo = expoModule('expo-audio', () => require('expo-audio'), ['ios', 'android', 'web']);
+    if (!expo)
+        throw new Error('[angular-native] expo-audio is not installed');
+    const updateInterval = options.timeUpdate === undefined ? undefined : options.timeUpdate * 1000;
+    const native = expo.createAudioPlayer(source, { updateInterval });
+    return own(native, () => watchAudioPlayer(native));
+}
+/**
+ * Tie a player's life to the component that made it.
+ *
+ * Called in an injection context, which is the same constraint the hooks have and for the same
+ * reason: something has to know when the thing goes away.
+ */
+function own(native, watch) {
+    const { state, stop } = watch();
+    inject(DestroyRef).onDestroy(stop);
+    return { native, state };
+}
+//# sourceMappingURL=player.js.map

package/dist/player.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"player.js","sourceRoot":"","sources":["../src/player.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Media players, bound to `expo-video` and `expo-audio`.\n *\n * ```ts\n * protected readonly player = videoPlayer(this.source, { timeUpdate: 0.5 });\n *\n * // <expo-video [player]=\"player.native\" />\n * // {{ player.state().currentTime }}\n * ```\n *\n * `useVideoPlayer` and `useAudioPlayer` are the documented way in, and the player they hand back\n * is not the React part - `createVideoPlayer` gives the same object. What the hooks add is the\n * two things a component actually needs and cannot get otherwise: the player is *released* when\n * the component goes, and its changing state is *readable*, because the player's own properties\n * are plain mutable fields that no template can watch.\n *\n * The player itself is passed straight through: it is a shared object with `play()`, `seekBy()`\n * and the rest already on it, and wrapping those would be a second place for each to be wrong.\n */\nimport { DestroyRef, inject, signal, type Signal } from '@angular/core';\nimport { expoModule } from './native.ts';\n\n/** The player's own status, which is the same word in both modules. */\nexport type PlayerStatus = 'idle' | 'loading' | 'readyToPlay' | 'error';\n\n/** The slice of a player this reads. Both modules' players satisfy it structurally. */\nexport interface NativePlayer {\n  addListener(event: string, listener: (payload: never) => void): { remove(): void };\n  release?(): void;\n  /** Seconds between `timeUpdate` events. Zero, its default, means the event never fires. `expo-video` only. */\n  timeUpdateEventInterval?: number;\n  /** Read directly rather than from an event: `expo-audio`'s status carries no volume field. */\n  readonly volume?: number;\n}\n\n/**\n * `expo-audio`'s one status event, `playbackStatusUpdate`. Unlike `expo-video`, which splits its\n * state across several named events, `AudioPlayer` reports everything - including errors - on a\n * single event, at the interval `updateInterval` was created with.\n */\nexport interface NativeAudioStatus {\n  readonly playing: boolean;\n  readonly mute: boolean;\n  readonly duration: number;\n  readonly currentTime: number;\n  readonly isLoaded: boolean;\n  readonly didJustFinish: boolean;\n  readonly error: string | null;\n}\n\nexport interface PlayerState {\n  readonly playing: boolean;\n  readonly status: PlayerStatus;\n  /** Seconds. Only moves while `timeUpdateEventInterval` is non-zero. */\n  readonly currentTime: number;\n  readonly duration: number;\n  readonly muted: boolean;\n  readonly volume: number;\n  /** Set once playback has run to the end, and cleared when it starts again. */\n  readonly ended: boolean;\n}\n\nconst INITIAL: PlayerState = {\n  playing: false,\n  status: 'idle',\n  currentTime: 0,\n  duration: 0,\n  muted: false,\n  volume: 1,\n  ended: false,\n};\n\n/**\n * Watch an `expo-video` player, and stop watching when the caller is done with it.\n *\n * `timeUpdate` defaults to off, so `currentTime` would never move. A caller that wants a progress\n * bar asks for one by passing an interval, and one that does not pays nothing: the event is the\n * most frequent thing the player emits.\n *\n * `expo-audio`'s player reports its state differently - one event, not several - so it is watched\n * by `watchAudioPlayer` below rather than this function.\n */\nexport function watchPlayer(\n  player: NativePlayer | null,\n  options: { timeUpdate?: number } = {},\n): { state: Signal<PlayerState>; stop: () => void } {\n  const state = signal(INITIAL);\n  if (!player) return { state: state.asReadonly(), stop: () => {} };\n\n  const patch = (change: Partial<PlayerState>) => state.update((last) => ({ ...last, ...change }));\n  const subscriptions = [\n    listen(player, 'statusChange', ({ status }: { status: PlayerStatus }) => patch({ status })),\n    listen(player, 'playingChange', ({ isPlaying }: { isPlaying: boolean }) =>\n      patch({ playing: isPlaying, ...(isPlaying ? { ended: false } : {}) }),\n    ),\n    listen(player, 'mutedChange', ({ muted }: { muted: boolean }) => patch({ muted })),\n    listen(player, 'volumeChange', ({ volume }: { volume: number }) => patch({ volume })),\n    listen(player, 'playToEnd', () => patch({ ended: true, playing: false })),\n    listen(player, 'timeUpdate', ({ currentTime }: { currentTime: number }) =>\n      patch({ currentTime }),\n    ),\n    listen(player, 'sourceChange', () => patch({ ...INITIAL, status: 'loading' })),\n    // The only event that says how long the video is: nothing else carries a duration.\n    listen(player, 'sourceLoad', ({ duration }: { duration: number }) => patch({ duration })),\n  ];\n\n  if (options.timeUpdate !== undefined) player.timeUpdateEventInterval = options.timeUpdate;\n\n  return {\n    state: state.asReadonly(),\n    stop: () => {\n      for (const subscription of subscriptions) subscription();\n      // Releasing is the half a hook does that nothing else will: a player left alive holds its\n      // decoder, its audio session and, on iOS, the now-playing controls.\n      player.release?.();\n    },\n  };\n}\n\nfunction listen<T>(player: NativePlayer, event: string, handler: (payload: T) => void): () => void {\n  const subscription = player.addListener(event, handler as (payload: never) => void);\n  return () => subscription.remove();\n}\n\n/**\n * Watch an `expo-audio` player, and stop watching when the caller is done with it.\n *\n * `AudioPlayer` reports its whole state on `playbackStatusUpdate`, at the interval it was created\n * with, rather than splitting it across the several events `expo-video` uses - so unlike\n * `watchPlayer`, there is one listener, not several, and nothing to reset on a source change: the\n * next status update carries the new source's own state.\n */\nfunction watchAudioPlayer(player: NativePlayer | null): {\n  state: Signal<PlayerState>;\n  stop: () => void;\n} {\n  const state = signal(INITIAL);\n  if (!player) return { state: state.asReadonly(), stop: () => {} };\n\n  const subscription = listen(player, 'playbackStatusUpdate', (status: NativeAudioStatus) =>\n    state.set({\n      playing: status.playing,\n      status: status.error !== null ? 'error' : status.isLoaded ? 'readyToPlay' : 'loading',\n      currentTime: status.currentTime,\n      duration: status.duration,\n      muted: status.mute,\n      // Not on the status event; the player's own property is the current value.\n      volume: player.volume ?? INITIAL.volume,\n      ended: status.didJustFinish,\n    }),\n  );\n\n  return {\n    state: state.asReadonly(),\n    stop: () => {\n      subscription();\n      // Releasing is the half a hook does that nothing else will: a player left alive holds its\n      // decoder, its audio session and, on iOS, the now-playing controls.\n      player.release?.();\n    },\n  };\n}\n\nexport interface Player<T> {\n  /** The module's own player, for `play()`, `seekBy()`, and to hand to its view. */\n  readonly native: T;\n  readonly state: Signal<PlayerState>;\n}\n\n/** A video player owned by the current component, released when it is destroyed. */\nexport function videoPlayer(\n  source: import('expo-video').VideoSource,\n  options: { timeUpdate?: number } = {},\n): Player<import('expo-video').VideoPlayer> {\n  const expo = expoModule(\n    'expo-video',\n    () => require('expo-video') as typeof import('expo-video'),\n    ['ios', 'android', 'web'],\n  );\n  if (!expo) throw new Error('[angular-native] expo-video is not installed');\n  const native = expo.createVideoPlayer(source);\n  return own(native, () => watchPlayer(native, options));\n}\n\n/**\n * An audio player owned by the current component, released when it is destroyed.\n *\n * `expo-audio` has no `timeUpdateEventInterval` property to set after the fact - the interval is\n * an option to `createAudioPlayer` itself, in milliseconds rather than `videoPlayer`'s seconds.\n */\nexport function audioPlayer(\n  source: import('expo-audio').AudioSource,\n  options: { timeUpdate?: number } = {},\n): Player<import('expo-audio').AudioPlayer> {\n  const expo = expoModule(\n    'expo-audio',\n    () => require('expo-audio') as typeof import('expo-audio'),\n    ['ios', 'android', 'web'],\n  );\n  if (!expo) throw new Error('[angular-native] expo-audio is not installed');\n  const updateInterval = options.timeUpdate === undefined ? undefined : options.timeUpdate * 1000;\n  const native = expo.createAudioPlayer(source, { updateInterval });\n  return own(native, () => watchAudioPlayer(native));\n}\n\n/**\n * Tie a player's life to the component that made it.\n *\n * Called in an injection context, which is the same constraint the hooks have and for the same\n * reason: something has to know when the thing goes away.\n */\nfunction own<T extends NativePlayer>(\n  native: T,\n  watch: () => { state: Signal<PlayerState>; stop: () => void },\n): Player<T> {\n  const { state, stop } = watch();\n  inject(DestroyRef).onDestroy(stop);\n  return { native, state };\n}\n"]}

package/dist/register-expo-view.d.ts

@@ -0,0 +1,55 @@
+/**
+ * The Fabric component name for a module's view, exactly as `requireNativeViewManager` computes
+ * it in `expo-modules-core`.
+ *
+ * The app identifier is the part that cannot be hardcoded. Expo Go runs many projects in one
+ * binary, so it namespaces every view name with a per-app suffix; a standalone build has no
+ * identifier and no suffix. Get it wrong and the view commits as `UnimplementedNativeView`
+ * with no error, which is the same failure mode as a misspelled name.
+ *
+ * A module with more than one view names the extra ones (`viewName`); the default view is the
+ * module itself.
+ */
+export declare function expoViewName(moduleName: string, viewName?: string): string;
+export interface ExpoViewOptions {
+    /** A named view on a module that has several. Omit for the module's default view. */
+    readonly viewName?: string;
+    /**
+     * Props the module's React component would have applied before native saw them. Expo's
+     * wrappers do less of this than React Native's, but they do some: `expo-image` resolves a
+     * source to an array and a `contentFit` to a string native understands.
+     */
+    readonly defaultProps?: Record<string, unknown>;
+}
+/**
+ * Teach the engine an element name for an Expo module's view, e.g.
+ * `registerExpoView('expo-image', 'ExpoImage')` makes `<expo-image>` commit as one.
+ *
+ * Call it at startup, before the first commit that uses the element. The app must have the
+ * module installed so the native side registers the component; this is the JavaScript half only.
+ */
+export declare function registerExpoView(elementName: string, moduleName: string, options?: ExpoViewOptions): void;
+/**
+ * The views worth knowing the names of, so an app does not have to look each one up.
+ *
+ * Deliberately names and defaults, not components. An Angular component per Expo view, prop for
+ * prop, is a maintenance burden with no end and a second place for every prop to be wrong; the
+ * element plus the module's own documentation covers the common case, and an app that wants a
+ * nicer surface writes the one component it actually needs.
+ *
+ * A module still has to be installed for its element to commit as anything: this is the
+ * JavaScript half. An element whose native side is missing commits as `UnimplementedNativeView`.
+ */
+export declare const EXPO_VIEWS: Readonly<Record<string, [string, ExpoViewOptions?]>>;
+/**
+ * Register several of the known views by element name.
+ *
+ * ```ts
+ * registerExpoViews('expo-image', 'expo-blur');
+ * ```
+ *
+ * Named one at a time rather than all at once on purpose: registering a view for a module the app
+ * has not installed produces an element that commits as nothing, and finding out at startup which
+ * modules are present is not something JavaScript can do without importing them all.
+ */
+export declare function registerExpoViews(...elements: readonly (keyof typeof EXPO_VIEWS)[]): void;

package/dist/register-expo-view.js

@@ -0,0 +1,110 @@
+/**
+ * Expo's native views, driven directly.
+ *
+ * An Expo module that renders something registers a Fabric component whose name it derives
+ * rather than declares, and `requireNativeViewManager` is the only place that derivation is
+ * written down. Everything else that function does is React: it caches a host component, builds
+ * a view config for React's renderer, and wraps the result in a class whose whole job is to hold
+ * a ref. None of that is reachable without React, and none of it is needed - the engine writes
+ * props onto the shadow node itself, and Expo's Fabric views take their props as an untyped map,
+ * so there is no codegen'd prop list to satisfy.
+ *
+ * What is left is the name. That is what this package is.
+ *
+ * No decorators and no Angular here on purpose: this is a registration, and the components it
+ * registers are ordinary elements in a template.
+ */
+import { registerViewName } from '@ng-native/fabric';
+/**
+ * The Fabric component name for a module's view, exactly as `requireNativeViewManager` computes
+ * it in `expo-modules-core`.
+ *
+ * The app identifier is the part that cannot be hardcoded. Expo Go runs many projects in one
+ * binary, so it namespaces every view name with a per-app suffix; a standalone build has no
+ * identifier and no suffix. Get it wrong and the view commits as `UnimplementedNativeView`
+ * with no error, which is the same failure mode as a misspelled name.
+ *
+ * A module with more than one view names the extra ones (`viewName`); the default view is the
+ * module itself.
+ */
+export function expoViewName(moduleName, viewName) {
+    const identifier = globalThis.expo?.__expo_app_identifier__ ?? '';
+    const suffix = identifier ? `_${identifier}` : '';
+    const module = viewName ? `${moduleName}_${viewName}` : moduleName;
+    return `ViewManagerAdapter_${module}${suffix}`;
+}
+/**
+ * Teach the engine an element name for an Expo module's view, e.g.
+ * `registerExpoView('expo-image', 'ExpoImage')` makes `<expo-image>` commit as one.
+ *
+ * Call it at startup, before the first commit that uses the element. The app must have the
+ * module installed so the native side registers the component; this is the JavaScript half only.
+ */
+export function registerExpoView(elementName, moduleName, options) {
+    registerViewName(elementName, expoViewName(moduleName, options?.viewName), options?.defaultProps);
+}
+/**
+ * The views worth knowing the names of, so an app does not have to look each one up.
+ *
+ * Deliberately names and defaults, not components. An Angular component per Expo view, prop for
+ * prop, is a maintenance burden with no end and a second place for every prop to be wrong; the
+ * element plus the module's own documentation covers the common case, and an app that wants a
+ * nicer surface writes the one component it actually needs.
+ *
+ * A module still has to be installed for its element to commit as anything: this is the
+ * JavaScript half. An element whose native side is missing commits as `UnimplementedNativeView`.
+ */
+export const EXPO_VIEWS = {
+    /** `expo-image`. Takes `source` as a list, so a single `{uri}` is wrapped by the caller. */
+    'expo-image': ['ExpoImage', { defaultProps: { contentFit: 'cover' } }],
+    /** `expo-blur`. The one thing CSS cannot express: a blur of what is *behind* a view. */
+    'expo-blur': ['ExpoBlurView', { defaultProps: { intensity: 50, tint: 'default' } }],
+    /** `expo-video`. The player itself is a shared object the module hands out; this is its view. */
+    'expo-video': ['ExpoVideo', { viewName: 'VideoView' }],
+    /**
+     * `expo-camera`. Its module's first view, so its default: `ExpoCamera_CameraView` exists only on
+     * iOS, after the Swift class, and commits as nothing on Android. `Camera` takes its pictures.
+     */
+    'expo-camera': ['ExpoCamera'],
+    /** `expo-apple-authentication`: Apple's Sign in with Apple button. iOS only. */
+    'apple-sign-in-button': ['ExpoAppleAuthentication'],
+    /** `expo-symbols`: SF Symbols, iOS only, and the reason `icons` is not needed for them. */
+    'expo-symbol': ['SymbolModule', { defaultProps: { type: 'monochrome' } }],
+    /** `expo-gl`, whose context is reached through an event rather than a prop. */
+    'expo-gl': ['ExpoGL'],
+    /** `expo-glass-effect`: the iOS 26 material. Renders as a plain view where it is unavailable. */
+    'expo-glass': ['ExpoGlassEffect', { viewName: 'GlassView' }],
+    /** Glass views that merge into one another when they come within `spacing` points. */
+    'expo-glass-container': ['ExpoGlassEffect', { viewName: 'GlassContainer' }],
+    /** `expo-mesh-gradient`: the one gradient CSS cannot express, because it has no CSS spelling. */
+    'expo-mesh-gradient': ['ExpoMeshGradient', { viewName: 'MeshGradientView' }],
+    /** `expo-live-photo`, iOS only. */
+    'expo-live-photo': ['ExpoLivePhoto', { viewName: 'LivePhotoView' }],
+    /**
+     * `expo-maps`, Google's on Android and Apple's on iOS: two modules, each with one view, so each
+     * its module's default. `ExpoMaps` itself is the permissions module and has no view.
+     * `MapView` (`<expo-map>`) types both as one element.
+     */
+    'expo-maps-google': ['ExpoGoogleMaps'],
+    'expo-maps-apple': ['ExpoAppleMaps'],
+};
+/**
+ * Register several of the known views by element name.
+ *
+ * ```ts
+ * registerExpoViews('expo-image', 'expo-blur');
+ * ```
+ *
+ * Named one at a time rather than all at once on purpose: registering a view for a module the app
+ * has not installed produces an element that commits as nothing, and finding out at startup which
+ * modules are present is not something JavaScript can do without importing them all.
+ */
+export function registerExpoViews(...elements) {
+    for (const element of elements) {
+        const known = EXPO_VIEWS[element];
+        if (!known)
+            throw new Error(`[angular-native] no Expo view is known as '${element}'`);
+        registerExpoView(element, known[0], known[1]);
+    }
+}
+//# sourceMappingURL=register-expo-view.js.map

package/dist/register-expo-view.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"register-expo-view.js","sourceRoot":"","sources":["../src/register-expo-view.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AACH,OAAO,EAAE,gBAAgB,EAAE,MAAM,mBAAmB,CAAC;AAUrD;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,YAAY,CAAC,UAAkB,EAAE,QAAiB;IAChE,MAAM,UAAU,GAAI,UAAoC,CAAC,IAAI,EAAE,uBAAuB,IAAI,EAAE,CAAC;IAC7F,MAAM,MAAM,GAAG,UAAU,CAAC,CAAC,CAAC,IAAI,UAAU,EAAE,CAAC,CAAC,CAAC,EAAE,CAAC;IAClD,MAAM,MAAM,GAAG,QAAQ,CAAC,CAAC,CAAC,GAAG,UAAU,IAAI,QAAQ,EAAE,CAAC,CAAC,CAAC,UAAU,CAAC;IACnE,OAAO,sBAAsB,MAAM,GAAG,MAAM,EAAE,CAAC;AACjD,CAAC;AAaD;;;;;;GAMG;AACH,MAAM,UAAU,gBAAgB,CAC9B,WAAmB,EACnB,UAAkB,EAClB,OAAyB;IAEzB,gBAAgB,CAAC,WAAW,EAAE,YAAY,CAAC,UAAU,EAAE,OAAO,EAAE,QAAQ,CAAC,EAAE,OAAO,EAAE,YAAY,CAAC,CAAC;AACpG,CAAC;AAED;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,UAAU,GAAyD;IAC9E,4FAA4F;IAC5F,YAAY,EAAE,CAAC,WAAW,EAAE,EAAE,YAAY,EAAE,EAAE,UAAU,EAAE,OAAO,EAAE,EAAE,CAAC;IACtE,wFAAwF;IACxF,WAAW,EAAE,CAAC,cAAc,EAAE,EAAE,YAAY,EAAE,EAAE,SAAS,EAAE,EAAE,EAAE,IAAI,EAAE,SAAS,EAAE,EAAE,CAAC;IACnF,iGAAiG;IACjG,YAAY,EAAE,CAAC,WAAW,EAAE,EAAE,QAAQ,EAAE,WAAW,EAAE,CAAC;IACtD;;;OAGG;IACH,aAAa,EAAE,CAAC,YAAY,CAAC;IAC7B,gFAAgF;IAChF,sBAAsB,EAAE,CAAC,yBAAyB,CAAC;IACnD,2FAA2F;IAC3F,aAAa,EAAE,CAAC,cAAc,EAAE,EAAE,YAAY,EAAE,EAAE,IAAI,EAAE,YAAY,EAAE,EAAE,CAAC;IACzE,+EAA+E;IAC/E,SAAS,EAAE,CAAC,QAAQ,CAAC;IACrB,iGAAiG;IACjG,YAAY,EAAE,CAAC,iBAAiB,EAAE,EAAE,QAAQ,EAAE,WAAW,EAAE,CAAC;IAC5D,sFAAsF;IACtF,sBAAsB,EAAE,CAAC,iBAAiB,EAAE,EAAE,QAAQ,EAAE,gBAAgB,EAAE,CAAC;IAC3E,iGAAiG;IACjG,oBAAoB,EAAE,CAAC,kBAAkB,EAAE,EAAE,QAAQ,EAAE,kBAAkB,EAAE,CAAC;IAC5E,mCAAmC;IACnC,iBAAiB,EAAE,CAAC,eAAe,EAAE,EAAE,QAAQ,EAAE,eAAe,EAAE,CAAC;IACnE;;;;OAIG;IACH,kBAAkB,EAAE,CAAC,gBAAgB,CAAC;IACtC,iBAAiB,EAAE,CAAC,eAAe,CAAC;CACrC,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,UAAU,iBAAiB,CAAC,GAAG,QAA8C;IACjF,KAAK,MAAM,OAAO,IAAI,QAAQ,EAAE,CAAC;QAC/B,MAAM,KAAK,GAAG,UAAU,CAAC,OAAO,CAAC,CAAC;QAClC,IAAI,CAAC,KAAK;YAAE,MAAM,IAAI,KAAK,CAAC,8CAA8C,OAAO,GAAG,CAAC,CAAC;QACtF,gBAAgB,CAAC,OAAO,EAAE,KAAK,CAAC,CAAC,CAAC,EAAE,KAAK,CAAC,CAAC,CAAC,CAAC,CAAC;IAChD,CAAC;AACH,CAAC","sourcesContent":["/**\n * Expo's native views, driven directly.\n *\n * An Expo module that renders something registers a Fabric component whose name it derives\n * rather than declares, and `requireNativeViewManager` is the only place that derivation is\n * written down. Everything else that function does is React: it caches a host component, builds\n * a view config for React's renderer, and wraps the result in a class whose whole job is to hold\n * a ref. None of that is reachable without React, and none of it is needed - the engine writes\n * props onto the shadow node itself, and Expo's Fabric views take their props as an untyped map,\n * so there is no codegen'd prop list to satisfy.\n *\n * What is left is the name. That is what this package is.\n *\n * No decorators and no Angular here on purpose: this is a registration, and the components it\n * registers are ordinary elements in a template.\n */\nimport { registerViewName } from '@ng-native/fabric';\n\n/**\n * What Expo installs on the global when the app starts. Only the app identifier matters here;\n * `getViewConfig` is for React's renderer, which never runs.\n */\ninterface ExpoGlobal {\n  readonly __expo_app_identifier__?: string;\n}\n\n/**\n * The Fabric component name for a module's view, exactly as `requireNativeViewManager` computes\n * it in `expo-modules-core`.\n *\n * The app identifier is the part that cannot be hardcoded. Expo Go runs many projects in one\n * binary, so it namespaces every view name with a per-app suffix; a standalone build has no\n * identifier and no suffix. Get it wrong and the view commits as `UnimplementedNativeView`\n * with no error, which is the same failure mode as a misspelled name.\n *\n * A module with more than one view names the extra ones (`viewName`); the default view is the\n * module itself.\n */\nexport function expoViewName(moduleName: string, viewName?: string): string {\n  const identifier = (globalThis as { expo?: ExpoGlobal }).expo?.__expo_app_identifier__ ?? '';\n  const suffix = identifier ? `_${identifier}` : '';\n  const module = viewName ? `${moduleName}_${viewName}` : moduleName;\n  return `ViewManagerAdapter_${module}${suffix}`;\n}\n\nexport interface ExpoViewOptions {\n  /** A named view on a module that has several. Omit for the module's default view. */\n  readonly viewName?: string;\n  /**\n   * Props the module's React component would have applied before native saw them. Expo's\n   * wrappers do less of this than React Native's, but they do some: `expo-image` resolves a\n   * source to an array and a `contentFit` to a string native understands.\n   */\n  readonly defaultProps?: Record<string, unknown>;\n}\n\n/**\n * Teach the engine an element name for an Expo module's view, e.g.\n * `registerExpoView('expo-image', 'ExpoImage')` makes `<expo-image>` commit as one.\n *\n * Call it at startup, before the first commit that uses the element. The app must have the\n * module installed so the native side registers the component; this is the JavaScript half only.\n */\nexport function registerExpoView(\n  elementName: string,\n  moduleName: string,\n  options?: ExpoViewOptions,\n): void {\n  registerViewName(elementName, expoViewName(moduleName, options?.viewName), options?.defaultProps);\n}\n\n/**\n * The views worth knowing the names of, so an app does not have to look each one up.\n *\n * Deliberately names and defaults, not components. An Angular component per Expo view, prop for\n * prop, is a maintenance burden with no end and a second place for every prop to be wrong; the\n * element plus the module's own documentation covers the common case, and an app that wants a\n * nicer surface writes the one component it actually needs.\n *\n * A module still has to be installed for its element to commit as anything: this is the\n * JavaScript half. An element whose native side is missing commits as `UnimplementedNativeView`.\n */\nexport const EXPO_VIEWS: Readonly<Record<string, [string, ExpoViewOptions?]>> = {\n  /** `expo-image`. Takes `source` as a list, so a single `{uri}` is wrapped by the caller. */\n  'expo-image': ['ExpoImage', { defaultProps: { contentFit: 'cover' } }],\n  /** `expo-blur`. The one thing CSS cannot express: a blur of what is *behind* a view. */\n  'expo-blur': ['ExpoBlurView', { defaultProps: { intensity: 50, tint: 'default' } }],\n  /** `expo-video`. The player itself is a shared object the module hands out; this is its view. */\n  'expo-video': ['ExpoVideo', { viewName: 'VideoView' }],\n  /**\n   * `expo-camera`. Its module's first view, so its default: `ExpoCamera_CameraView` exists only on\n   * iOS, after the Swift class, and commits as nothing on Android. `Camera` takes its pictures.\n   */\n  'expo-camera': ['ExpoCamera'],\n  /** `expo-apple-authentication`: Apple's Sign in with Apple button. iOS only. */\n  'apple-sign-in-button': ['ExpoAppleAuthentication'],\n  /** `expo-symbols`: SF Symbols, iOS only, and the reason `icons` is not needed for them. */\n  'expo-symbol': ['SymbolModule', { defaultProps: { type: 'monochrome' } }],\n  /** `expo-gl`, whose context is reached through an event rather than a prop. */\n  'expo-gl': ['ExpoGL'],\n  /** `expo-glass-effect`: the iOS 26 material. Renders as a plain view where it is unavailable. */\n  'expo-glass': ['ExpoGlassEffect', { viewName: 'GlassView' }],\n  /** Glass views that merge into one another when they come within `spacing` points. */\n  'expo-glass-container': ['ExpoGlassEffect', { viewName: 'GlassContainer' }],\n  /** `expo-mesh-gradient`: the one gradient CSS cannot express, because it has no CSS spelling. */\n  'expo-mesh-gradient': ['ExpoMeshGradient', { viewName: 'MeshGradientView' }],\n  /** `expo-live-photo`, iOS only. */\n  'expo-live-photo': ['ExpoLivePhoto', { viewName: 'LivePhotoView' }],\n  /**\n   * `expo-maps`, Google's on Android and Apple's on iOS: two modules, each with one view, so each\n   * its module's default. `ExpoMaps` itself is the permissions module and has no view.\n   * `MapView` (`<expo-map>`) types both as one element.\n   */\n  'expo-maps-google': ['ExpoGoogleMaps'],\n  'expo-maps-apple': ['ExpoAppleMaps'],\n};\n\n/**\n * Register several of the known views by element name.\n *\n * ```ts\n * registerExpoViews('expo-image', 'expo-blur');\n * ```\n *\n * Named one at a time rather than all at once on purpose: registering a view for a module the app\n * has not installed produces an element that commits as nothing, and finding out at startup which\n * modules are present is not something JavaScript can do without importing them all.\n */\nexport function registerExpoViews(...elements: readonly (keyof typeof EXPO_VIEWS)[]): void {\n  for (const element of elements) {\n    const known = EXPO_VIEWS[element];\n    if (!known) throw new Error(`[angular-native] no Expo view is known as '${element}'`);\n    registerExpoView(element, known[0], known[1]);\n  }\n}\n"]}

package/dist/screen-capture.d.ts

@@ -0,0 +1,58 @@
+/**
+ * `ScreenCapture`, bound to `expo-screen-capture`: keeping a screen out of screenshots and
+ * recordings, and knowing when one was taken.
+ *
+ * ```ts
+ * private readonly capture = inject(ScreenCapture);
+ *
+ * constructor() {
+ *   void this.capture.prevent('card-details');
+ *   inject(DestroyRef).onDestroy(() => void this.capture.allow('card-details'));
+ * }
+ * ```
+ *
+ * `prevent()` and `allow()` take a key, and capture stays prevented while any key is still held:
+ * two screens that each prevent it do not undo each other. `screenshots` counts the screenshots
+ * the user has taken, and the listener behind it lives as long as the app does and is removed
+ * when the app is destroyed. Without the module installed, nothing is prevented and the count
+ * stays at zero.
+ */
+import { InjectionToken, type Signal } from '@angular/core';
+import { Permission } from './permissions.ts';
+import * as i0 from "@angular/core";
+type Expo = typeof import('expo-screen-capture');
+/** The module's functions this service calls. The real module is one; a test provides a fake. */
+export type NativeScreenCapture = Pick<Expo, 'isAvailableAsync' | 'preventScreenCaptureAsync' | 'allowScreenCaptureAsync' | 'enableAppSwitcherProtectionAsync' | 'disableAppSwitcherProtectionAsync' | 'addScreenshotListener' | 'getPermissionsAsync' | 'requestPermissionsAsync'>;
+export declare class ScreenCapture {
+    /** Overridden in a test to take screenshots nobody took. */
+    static readonly SOURCE: InjectionToken<NativeScreenCapture | null>;
+    private readonly native;
+    private readonly count;
+    /**
+     * The permission screenshot detection needs on Android 13 and earlier, where it reads the
+     * photo library. Later Android needs none, and iOS always answers granted.
+     */
+    readonly permission: Permission;
+    /** How many screenshots the user has taken while the app was in front. */
+    readonly screenshots: Signal<number>;
+    constructor();
+    /** Whether the platform can prevent capture. */
+    available(): Promise<boolean>;
+    /**
+     * Keeps the app out of screenshots and screen recordings until `allow()` is called with the same
+     * key, or the app restarts. Omitting the key uses one shared default key.
+     */
+    prevent(key?: string): Promise<void>;
+    /** Releases the key; capture is allowed again once no key is held. */
+    allow(key?: string): Promise<void>;
+    /**
+     * iOS: blurs the app while it is not in focus - in the app switcher, in the background, and
+     * during interruptions - by `blurIntensity` from 0 to 1, half by default. Android already hides
+     * it in the app switcher while capture is prevented.
+     */
+    protectAppSwitcher(blurIntensity?: number): Promise<void>;
+    unprotectAppSwitcher(): Promise<void>;
+    static ɵfac: i0.ɵɵFactoryDeclaration<ScreenCapture, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<any>;
+}
+export {};