@symbiote-native/screen-capture 0.0.0-stage → 0.1.1

package/LICENSE

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

package/README.md

@@ -1,3 +1,138 @@
-# Temporary Holding Version
+# @symbiote-native/screen-capture
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+Keep a screen that shows sensitive or paid content out of screenshots and recordings, and find out
+when a screenshot is taken. One API for every [SymbioteNative](../../README.md) adapter (React,
+Vue, Svelte, Solid and Angular).
+
+It wraps [`expo-screen-capture`](https://github.com/expo/expo/tree/main/packages/expo-screen-capture)
+(including an iOS app-switcher privacy blur) the same way [`@symbiote-native/print`](../print)
+wraps its upstream: `expo-modules-core` is a direct dependency and the upstream JS is hand-ported
+into `core/`. See the `symbiote-expo-native-module` project skill for the full mechanism.
+
+## Install
+
+**New app:**
+
+```bash
+npx @symbiote-native/cli new my-app --screen-capture
+```
+
+**Existing SymbioteNative app:**
+
+```bash
+npx @symbiote-native/cli add --screen-capture
+```
+
+Either way: installs `@symbiote-native/screen-capture` and wires the native autolinking
+automatically, see [`@symbiote-native/cli`](../cli).
+
+<details>
+<summary>Manual install (no CLI - installing and wiring native autolinking by hand)</summary>
+
+```bash
+npm install @symbiote-native/screen-capture
+```
+
+`expo-screen-capture` and `expo-modules-core` come along as regular, pinned dependencies, never
+install either yourself, and never add the `expo` meta-package to this project.
+
+### Required one-time step: native autolinking wiring
+
+Same one-time app wiring every `expo-modules-core` package shares, see
+[`@symbiote-native/print`'s README](../print/README.md#required-one-time-step-native-autolinking-wiring)
+for the full table; nothing package-specific here.
+
+### Permissions and no config plugin
+
+- **No config plugin.** Upstream ships none.
+- **Android screenshot detection** needs a storage-read permission on API < 33 (`READ_MEDIA_IMAGES`
+  on API 33, `READ_EXTERNAL_STORAGE` below it, nothing on API 34+). Both entries ship in
+  `expo-screen-capture`'s own bundled `AndroidManifest.xml` and auto-merge via Gradle's manifest
+  merger, no `native-link.json` entry needed.
+- **iOS never needs a permission**: `getPermissionsAsync`/`requestPermissionsAsync` always
+  resolve granted there, matching upstream.
+
+</details>
+
+## Shape
+
+```
+src/core/                 the async functions + the shared permissions-runtime get/request wrapper.
+                          native-module.ts resolves ExpoScreenCapture through expo-modules-core's
+                          requireNativeModule.
+src/react/                usePreventScreenCapture + useScreenshotListener + usePermissions (hooks)
+src/vue/                  same three, as composables
+src/solid/                same three, as primitives
+src/svelte/               same three, as runes
+src/angular/              PreventScreenCaptureService + ScreenshotListenerService +
+                          PermissionsService, `connect()` shape matching
+                          `@symbiote-native/keep-awake`/`brightness`'s own services
+```
+
+The plain async functions stay framework-agnostic, re-exported by every adapter's own barrel.
+`usePreventScreenCapture`/`useScreenshotListener`/`usePermissions` are ported to **every**
+adapter, not just React, per this project's `components_split_logic_view_lifecycle` convention.
+
+## Use it
+
+```ts
+import {
+  addScreenshotListener,
+  preventScreenCaptureAsync,
+  allowScreenCaptureAsync,
+} from '@symbiote-native/screen-capture';
+
+await preventScreenCaptureAsync();
+const subscription = addScreenshotListener(() => console.log('screenshot taken'));
+// later
+subscription.remove();
+await allowScreenCaptureAsync();
+```
+
+## API
+
+| Export                               | Signature                                                | Notes                                                    |
+| ------------------------------------- | ----------------------------------------------------------- | ----------------------------------------------------------- |
+| `isAvailableAsync`                    | `() => Promise<boolean>`                                     | Whether the native module implements the prevent/allow pair. |
+| `preventScreenCaptureAsync`           | `(key?: string) => Promise<void>`                            | Blocks screenshots/recordings until a matching `allowScreenCaptureAsync`. |
+| `allowScreenCaptureAsync`             | `(key?: string) => Promise<void>`                            | Re-allows once every active key is released.                 |
+| `enableAppSwitcherProtectionAsync`    | `(blurIntensity?: number) => Promise<void>`                   | iOS only; throws `UnavailabilityError` on Android.            |
+| `disableAppSwitcherProtectionAsync`   | `() => Promise<void>`                                        | iOS only; throws `UnavailabilityError` on Android.            |
+| `addScreenshotListener`               | `(listener: () => void) => EventSubscription`                | Fires when the user takes a screenshot while foregrounded.    |
+| `removeScreenshotListener`            | `(subscription: EventSubscription) => void`                  | Deprecated upstream; prefer `subscription.remove()`.          |
+| `getPermissionsAsync`                 | `() => Promise<PermissionResponse>`                           | Android-only concept; always granted on iOS.                  |
+| `requestPermissionsAsync`             | `() => Promise<PermissionResponse>`                           | Android-only concept; always granted on iOS.                  |
+
+## Notes
+
+- **Prevent and allow are counted by key.** Use a distinct `key` per caller so one screen leaving
+  does not unblock another.
+- **Screenshot callback on Android 13 and lower needs `READ_MEDIA_IMAGES`.** Android 14+ needs no
+  permission for blocking or the callback. Google Play restricts that permission to apps that need
+  broad photo access.
+- **Test on an emulator:** `adb shell input keyevent 120` triggers a screenshot on Android; the iOS
+  Simulator has Device > Trigger Screenshot.
+
+## Common questions
+
+- **What does a protected screen look like?** Blocked or black on Android; hidden behind a blank
+  layer on iOS. Test on a device.
+- **The prevent hook does nothing.** Check it runs on mount on a real device or emulator, and use a
+  distinct `key` per caller.
+- **The screenshot callback never fires.** Foreground only; Android 13 and lower need
+  `READ_MEDIA_IMAGES`.
+- **App switcher preview.** Call `enableAppSwitcherProtectionAsync()` on iOS.
+
+Sources: [Expo docs: ScreenCapture](https://docs.expo.dev/versions/latest/sdk/screen-capture/),
+[expo/expo#37874](https://github.com/expo/expo/pull/37874),
+[expo/expo#21416](https://github.com/expo/expo/issues/21416).
+
+## Test it
+
+```bash
+pnpm vitest run packages/screen-capture
+```
+
+Upstream ships no test suite of its own for this SDK version, so nothing to port, every test
+here is net-new coverage (key-counted prevent/allow, the app-switcher pair's iOS-only failure,
+the screenshot listener, and the permission fallback on iOS).

package/build/angular/index.d.ts

@@ -0,0 +1,4 @@
+export * from '../core';
+export { PreventScreenCaptureService } from './services/prevent-screen-capture.service';
+export { ScreenshotListenerService } from './services/screenshot-listener.service';
+export { PermissionsService } from './services/permissions.service';

package/build/angular/index.js

@@ -0,0 +1,4 @@
+export * from '../core/index.js';
+export { PreventScreenCaptureService } from './services/prevent-screen-capture.service/index.js';
+export { ScreenshotListenerService } from './services/screenshot-listener.service/index.js';
+export { PermissionsService } from './services/permissions.service/index.js';

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

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

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

@@ -0,0 +1,59 @@
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { Injectable } from '@angular/core';
+import { PermissionsServiceBase } from '@symbiote-native/angular';
+import { getPermissionsAsync, requestPermissionsAsync } from '../../../core/index.js';
+let PermissionsService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    let _classSuper = PermissionsServiceBase;
+    var PermissionsService = class extends _classSuper {
+        static { _classThis = this; }
+        static {
+            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;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        constructor() {
+            super(getPermissionsAsync, requestPermissionsAsync);
+        }
+    };
+    return PermissionsService = _classThis;
+})();
+export { PermissionsService };

package/build/angular/services/prevent-screen-capture.service/index.d.ts

@@ -0,0 +1,4 @@
+export declare class PreventScreenCaptureService {
+    private readonly injector;
+    connect(key?: string): void;
+}

package/build/angular/services/prevent-screen-capture.service/index.js

@@ -0,0 +1,65 @@
+// Angular twin of `../../react`'s `usePreventScreenCapture`, `connect()` shape matching
+// `@symbiote-native/keep-awake`'s own `KeepAwakeService`
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { effect, inject, Injectable, Injector } from '@angular/core';
+import { allowScreenCaptureAsync, preventScreenCaptureAsync, } from '../../../core/index.js';
+let PreventScreenCaptureService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var PreventScreenCaptureService = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            PreventScreenCaptureService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        injector = inject(Injector);
+        connect(key = 'default') {
+            effect(onCleanup => {
+                preventScreenCaptureAsync(key);
+                onCleanup(() => {
+                    allowScreenCaptureAsync(key);
+                });
+            }, { injector: this.injector });
+        }
+    };
+    return PreventScreenCaptureService = _classThis;
+})();
+export { PreventScreenCaptureService };

package/build/angular/services/screenshot-listener.service/index.d.ts

@@ -0,0 +1,4 @@
+export declare class ScreenshotListenerService {
+    private readonly injector;
+    connect(listener: () => void): void;
+}

package/build/angular/services/screenshot-listener.service/index.js

@@ -0,0 +1,65 @@
+// Angular twin of `../../react`'s `useScreenshotListener`, `connect()` shape matching
+// `@symbiote-native/keep-awake`'s own `KeepAwakeService`
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+import { effect, inject, Injectable, Injector } from '@angular/core';
+import { addScreenshotListener } from '../../../core/index.js';
+let ScreenshotListenerService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var ScreenshotListenerService = class {
+        static { _classThis = this; }
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(null) : void 0;
+            __esDecorate(null, _classDescriptor = { value: _classThis }, _classDecorators, { kind: "class", name: _classThis.name, metadata: _metadata }, null, _classExtraInitializers);
+            ScreenshotListenerService = _classThis = _classDescriptor.value;
+            if (_metadata) Object.defineProperty(_classThis, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+            __runInitializers(_classThis, _classExtraInitializers);
+        }
+        injector = inject(Injector);
+        connect(listener) {
+            effect(onCleanup => {
+                const subscription = addScreenshotListener(listener);
+                onCleanup(() => {
+                    subscription.remove();
+                });
+            }, { injector: this.injector });
+        }
+    };
+    return ScreenshotListenerService = _classThis;
+})();
+export { ScreenshotListenerService };

package/build/core/index.d.ts

@@ -0,0 +1,2 @@
+export { addScreenshotListener, allowScreenCaptureAsync, disableAppSwitcherProtectionAsync, enableAppSwitcherProtectionAsync, getPermissionsAsync, isAvailableAsync, preventScreenCaptureAsync, removeScreenshotListener, requestPermissionsAsync, } from './screen-capture';
+export { PermissionStatus, type EventSubscription, type PermissionExpiration, type PermissionResponse, } from 'expo-modules-core';

package/build/core/index.js

@@ -0,0 +1,2 @@
+export { addScreenshotListener, allowScreenCaptureAsync, disableAppSwitcherProtectionAsync, enableAppSwitcherProtectionAsync, getPermissionsAsync, isAvailableAsync, preventScreenCaptureAsync, removeScreenshotListener, requestPermissionsAsync, } from './screen-capture.js';
+export { PermissionStatus, } from 'expo-modules-core';

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

@@ -0,0 +1,13 @@
+import type { EventSubscription, PermissionResponse } from 'expo-modules-core';
+export declare const ON_SCREENSHOT_EVENT_NAME = "onScreenshot";
+export type INativeScreenCaptureModule = {
+    addListener(eventName: typeof ON_SCREENSHOT_EVENT_NAME, listener: () => void): EventSubscription;
+    removeAllListeners(eventName: typeof ON_SCREENSHOT_EVENT_NAME): void;
+    preventScreenCapture?(): Promise<void>;
+    allowScreenCapture?(): Promise<void>;
+    enableAppSwitcherProtection?(blurIntensity: number): Promise<void>;
+    disableAppSwitcherProtection?(): Promise<void>;
+    getPermissionsAsync?(): Promise<PermissionResponse>;
+    requestPermissionsAsync?(): Promise<PermissionResponse>;
+};
+export declare const expoScreenCapture: INativeScreenCaptureModule;

package/build/core/native-module.js

@@ -0,0 +1,4 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPO_SCREEN_CAPTURE_MODULE_NAME = 'ExpoScreenCapture';
+export const ON_SCREENSHOT_EVENT_NAME = 'onScreenshot';
+export const expoScreenCapture = requireNativeModule(EXPO_SCREEN_CAPTURE_MODULE_NAME);

package/build/core/permissions-runtime.d.ts

@@ -0,0 +1,5 @@
+export type IPermissionsApi<TPermission> = {
+    get: () => Promise<TPermission>;
+    request: () => Promise<TPermission>;
+};
+export declare function createPermissionsApi<TPermission>(getMethod: () => Promise<TPermission>, requestMethod: () => Promise<TPermission>, record: (response: TPermission) => void): IPermissionsApi<TPermission>;

package/build/core/permissions-runtime.js

@@ -0,0 +1,16 @@
+// The get/request wrapper every adapter's `usePermissions` needs, extracted once so
+// `src/vue`/`src/solid`/`src/svelte`/`src/react` each supply only their own state primitive
+export function createPermissionsApi(getMethod, requestMethod, record) {
+    return {
+        get: async () => {
+            const response = await getMethod();
+            record(response);
+            return response;
+        },
+        request: async () => {
+            const response = await requestMethod();
+            record(response);
+            return response;
+        },
+    };
+}

package/build/core/screen-capture.d.ts

@@ -0,0 +1,16 @@
+import type { EventSubscription, PermissionResponse } from 'expo-modules-core';
+export declare function isAvailableAsync(): Promise<boolean>;
+/** Repeated calls with the same `key` are no-ops until a matching `allowScreenCaptureAsync`. */
+export declare function preventScreenCaptureAsync(key?: string): Promise<void>;
+export declare function allowScreenCaptureAsync(key?: string): Promise<void>;
+/** iOS only; throws `UnavailabilityError` on Android. */
+export declare function enableAppSwitcherProtectionAsync(blurIntensity?: number): Promise<void>;
+/** iOS only; throws `UnavailabilityError` on Android. */
+export declare function disableAppSwitcherProtectionAsync(): Promise<void>;
+export declare function addScreenshotListener(listener: () => void): EventSubscription;
+/** @deprecated use `subscription.remove()` instead. */
+export declare function removeScreenshotListener(subscription: EventSubscription): void;
+/** Only Android requires a permission to detect screenshots; iOS always resolves granted. */
+export declare function getPermissionsAsync(): Promise<PermissionResponse>;
+/** Only Android requires a permission to detect screenshots; iOS always resolves granted. */
+export declare function requestPermissionsAsync(): Promise<PermissionResponse>;

package/build/core/screen-capture.js

@@ -0,0 +1,68 @@
+import { PermissionStatus, UnavailabilityError } from 'expo-modules-core';
+import { expoScreenCapture, ON_SCREENSHOT_EVENT_NAME } from './native-module.js';
+const NATIVE_MODULE_NAME = 'ScreenCapture';
+const activeKeys = new Set();
+export async function isAvailableAsync() {
+    return (!!expoScreenCapture.preventScreenCapture &&
+        !!expoScreenCapture.allowScreenCapture);
+}
+/** Repeated calls with the same `key` are no-ops until a matching `allowScreenCaptureAsync`. */
+export async function preventScreenCaptureAsync(key = 'default') {
+    if (!expoScreenCapture.preventScreenCapture) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'preventScreenCaptureAsync');
+    }
+    if (!activeKeys.has(key)) {
+        activeKeys.add(key);
+        await expoScreenCapture.preventScreenCapture();
+    }
+}
+export async function allowScreenCaptureAsync(key = 'default') {
+    if (!expoScreenCapture.allowScreenCapture) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'allowScreenCaptureAsync');
+    }
+    activeKeys.delete(key);
+    if (activeKeys.size === 0) {
+        await expoScreenCapture.allowScreenCapture();
+    }
+}
+/** iOS only; throws `UnavailabilityError` on Android. */
+export async function enableAppSwitcherProtectionAsync(blurIntensity = 0.5) {
+    if (!expoScreenCapture.enableAppSwitcherProtection) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'enableAppSwitcherProtectionAsync');
+    }
+    await expoScreenCapture.enableAppSwitcherProtection(blurIntensity);
+}
+/** iOS only; throws `UnavailabilityError` on Android. */
+export async function disableAppSwitcherProtectionAsync() {
+    if (!expoScreenCapture.disableAppSwitcherProtection) {
+        throw new UnavailabilityError(NATIVE_MODULE_NAME, 'disableAppSwitcherProtectionAsync');
+    }
+    await expoScreenCapture.disableAppSwitcherProtection();
+}
+export function addScreenshotListener(listener) {
+    return expoScreenCapture.addListener(ON_SCREENSHOT_EVENT_NAME, listener);
+}
+/** @deprecated use `subscription.remove()` instead. */
+export function removeScreenshotListener(subscription) {
+    subscription.remove();
+}
+const defaultPermissionsResponse = {
+    granted: true,
+    expires: 'never',
+    canAskAgain: true,
+    status: PermissionStatus.GRANTED,
+};
+/** Only Android requires a permission to detect screenshots; iOS always resolves granted. */
+export async function getPermissionsAsync() {
+    if (expoScreenCapture.getPermissionsAsync) {
+        return expoScreenCapture.getPermissionsAsync();
+    }
+    return defaultPermissionsResponse;
+}
+/** Only Android requires a permission to detect screenshots; iOS always resolves granted. */
+export async function requestPermissionsAsync() {
+    if (expoScreenCapture.requestPermissionsAsync) {
+        return expoScreenCapture.requestPermissionsAsync();
+    }
+    return defaultPermissionsResponse;
+}

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

@@ -0,0 +1,7 @@
+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

@@ -0,0 +1,37 @@
+// Same shape as `@symbiote-native/brightness`'s own `usePermissions` by design - each package
+// owns its copy. The mount fetch has nobody to reject to, so its failure lands in the 4th
+// tuple slot (`error`)
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { getPermissionsAsync, requestPermissionsAsync } 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 getPermissionsAsync();
+        if (isMounted.current) {
+            setStatus(response);
+            setError(null);
+        }
+        return response;
+    }, []);
+    const requestPermission = useCallback(async () => {
+        const response = await requestPermissionsAsync();
+        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/react/hooks/use-prevent-screen-capture/index.d.ts

@@ -0,0 +1 @@
+export declare function usePreventScreenCapture(key?: string): void;

package/build/react/hooks/use-prevent-screen-capture/index.js

@@ -0,0 +1,12 @@
+// React lifecycle wiring over the framework-agnostic core (core/screen-capture.ts): prevents on
+// mount, allows on unmount, mirroring upstream's `usePreventScreenCapture`
+import { useEffect } from 'react';
+import { allowScreenCaptureAsync, preventScreenCaptureAsync, } from '../../../core/index.js';
+export function usePreventScreenCapture(key = 'default') {
+    useEffect(() => {
+        preventScreenCaptureAsync(key);
+        return () => {
+            allowScreenCaptureAsync(key);
+        };
+    }, [key]);
+}

package/build/react/hooks/use-screenshot-listener/index.d.ts

@@ -0,0 +1 @@
+export declare function useScreenshotListener(listener: () => void): void;

package/build/react/hooks/use-screenshot-listener/index.js

@@ -0,0 +1,12 @@
+// React lifecycle wiring over the framework-agnostic core (core/screen-capture.ts): subscribes
+// on mount, unsubscribes on unmount, mirroring upstream's `useScreenshotListener`
+import { useEffect } from 'react';
+import { addScreenshotListener } from '../../../core/index.js';
+export function useScreenshotListener(listener) {
+    useEffect(() => {
+        const subscription = addScreenshotListener(listener);
+        return () => {
+            subscription.remove();
+        };
+    }, [listener]);
+}

package/build/react/index.d.ts

@@ -0,0 +1,4 @@
+export * from '../core';
+export { usePreventScreenCapture } from './hooks/use-prevent-screen-capture';
+export { useScreenshotListener } from './hooks/use-screenshot-listener';
+export { usePermissions } from './hooks/use-permissions';

package/build/react/index.js

@@ -0,0 +1,4 @@
+export * from '../core/index.js';
+export { usePreventScreenCapture } from './hooks/use-prevent-screen-capture/index.js';
+export { useScreenshotListener } from './hooks/use-screenshot-listener/index.js';
+export { usePermissions } from './hooks/use-permissions/index.js';

package/build/solid/index.d.ts

@@ -0,0 +1,4 @@
+export * from '../core';
+export { createPreventScreenCapture } from './primitives/create-prevent-screen-capture';
+export { createScreenshotListener } from './primitives/create-screenshot-listener';
+export { createPermissions } from './primitives/create-permissions';

package/build/solid/index.js

@@ -0,0 +1,4 @@
+export * from '../core/index.js';
+export { createPreventScreenCapture } from './primitives/create-prevent-screen-capture.js';
+export { createScreenshotListener } from './primitives/create-screenshot-listener.js';
+export { createPermissions } from './primitives/create-permissions.js';

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

@@ -0,0 +1,8 @@
+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>;
+};