@symbiote-native/keep-awake 0.0.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

@@ -0,0 +1,148 @@
+# @symbiote-native/keep-awake
+
+Port of [`expo-keep-awake`](https://docs.expo.dev/versions/latest/sdk/keep-awake/) for
+[SymbioteNative](../../README.md) — keeps the screen on for the lifetime of a mounted
+component/composable/service, reachable from every adapter (React, Vue, Angular), not just
+React.
+
+Built the same way as [`@symbiote-native/battery`](../battery) and
+[`@symbiote-native/device`](../device), an `expo-modules-core`-based wrapper (see the
+`symbiote-expo-native-module` project skill for the full mechanism: why `expo-modules-core` is
+depended on directly and never the `expo` meta-package, why the upstream JS is hand-ported into
+`core/` rather than imported, and how autolinking picks up the native module).
+
+## Install
+
+```bash
+npm install @symbiote-native/keep-awake
+```
+
+Depends on `expo-keep-awake` and `expo-modules-core` directly (regular dependencies, pinned to
+exact versions — never a caret range, since this package's `core/` is hand-ported against one
+specific native API shape and a newer resolve could silently drift the two apart). Never install
+`expo-keep-awake` yourself, and never add the `expo` package to this project — it bundles its own
+Metro/Babel pipeline that conflicts with this project's own.
+
+### Required one-time step: native autolinking wiring
+
+Unlike a plain RN native module, `expo-keep-awake`'s native code is discovered by
+`expo-modules-autolinking`, not RN's own `react-native.config.cjs` mechanism — this needs wiring
+into the native host app **once**, covering this package and every other `expo-modules-core`
+package (`@symbiote-native/battery`, `@symbiote-native/device`, `@symbiote-native/sensors`, …)
+with zero further changes:
+
+| Platform | Touches |
+|---|---|
+| iOS | `ios/Podfile` — add `use_expo_modules!` |
+| iOS | `AppDelegate.swift` — Expo's runtime-bootstrap hook |
+| Android | `settings.gradle` / `app/build.gradle` — resolve and include the Expo Gradle projects |
+| Android | `MainApplication.kt` — Expo's bootstrap hook, plus a hand-written native-module name map (there's no `expo` meta-package here to auto-generate one) |
+
+The recurring per-package half of the Android wiring (`app/build.gradle`'s
+`implementation project(':expo-keep-awake')` line and `MainApplication.kt`'s module-name map
+entry) is automated by this package's own `postinstall` script via
+`@symbiote-native/expo-modules-link` — see that package's README for how the `native-link.json`
+manifest above drives it. Full mechanics — the Podfile pieces that normally ship inside the
+`expo` package, the `expo` peer-dependency exclusion list — live in the
+`symbiote-expo-native-module` skill.
+
+No platform permission string is needed — keeping the screen awake has no runtime permission
+prompt on either platform.
+
+## Shape
+
+```
+src/core/               keep-awake.ts — isAvailableAsync/activateKeepAwakeAsync/
+                        deactivateKeepAwake/addListener, ExpoKeepAwakeTag. native-module.ts
+                        resolves the native module through expo-modules-core's
+                        requireNativeModule. types.ts — KeepAwakeEvent/KeepAwakeListener/
+                        KeepAwakeOptions, hand-ported from KeepAwake.types.ts.
+src/react/hooks/        @symbiote-native/keep-awake/react   — useKeepAwake
+src/vue/composables/    @symbiote-native/keep-awake/vue     — useKeepAwake
+src/angular/services/   @symbiote-native/keep-awake/angular — KeepAwakeService (`.connect()`,
+                        no return value — a pure side effect for the component's lifetime)
+```
+
+Each adapter's hook/composable/service activates a keep-awake lock on mount and deactivates it on
+unmount, over the same `core` functions — the tag-generation and activate/deactivate lifecycle is
+written once and shared by all three. React uses `useId()` for its default per-instance tag,
+matching upstream; Vue and Angular have no `useId` equivalent, so both fall back to a small
+monotonically-incrementing module-local counter (`keep-awake-tag-1`, `keep-awake-tag-2`, …) when
+no explicit tag is given.
+
+## Use it
+
+```tsx
+// React — examples/expo-react/screens/KeepAwakeScreen.tsx
+import { useKeepAwake } from '@symbiote-native/keep-awake/react';
+
+function KeepAwakeScreen() {
+  useKeepAwake(); // screen stays on for as long as this component is mounted
+
+  return <Text>Screen will not sleep</Text>;
+}
+```
+
+```vue
+<!-- Vue — examples/expo-vue-sfc/screens/KeepAwakeScreen.vue -->
+<script setup lang="ts">
+import { useKeepAwake } from '@symbiote-native/keep-awake/vue';
+
+useKeepAwake();
+</script>
+<template>
+  <Text>Screen will not sleep</Text>
+</template>
+```
+
+```ts
+// Angular — examples/expo-angular/src/screens/KeepAwakeScreen.ts
+import { Component, inject } from '@angular/core';
+import { KeepAwakeService } from '@symbiote-native/keep-awake/angular';
+
+@Component({ /* ... */ })
+export class KeepAwakeScreen {
+  constructor() {
+    inject(KeepAwakeService).connect();
+  }
+}
+```
+
+## API
+
+```ts
+isAvailableAsync(): Promise<boolean>                          // keep-awake API availability on this device
+activateKeepAwakeAsync(tag?: string): Promise<void>           // acquires a lock under `tag` (default tag when omitted)
+deactivateKeepAwake(tag?: string): Promise<void>              // releases the lock under `tag` (default tag when omitted)
+addListener(tagOrListener, listener?): EventSubscription      // subscribes to keep-awake state changes
+```
+
+Plus `ExpoKeepAwakeTag` (the shared default tag string), `KeepAwakeEvent`, `KeepAwakeListener`,
+`KeepAwakeOptions` — ported from upstream's `KeepAwake.types.ts`. `KeepAwakeEvent#state` is kept
+as a minimal `unknown` placeholder: upstream's own shape there is web-specific and has no native
+analogue, and native listeners for it rarely fire.
+
+```ts
+import { activateKeepAwakeAsync, deactivateKeepAwake } from '@symbiote-native/keep-awake';
+
+// framework-scoped entry points re-export the same free functions, plus a lifecycle
+// hook/composable/service:
+import { useKeepAwake } from '@symbiote-native/keep-awake/react';
+import { useKeepAwake } from '@symbiote-native/keep-awake/vue';
+import { KeepAwakeService } from '@symbiote-native/keep-awake/angular';
+```
+
+Each hook/composable/service activates a lock on mount (optionally registering `options.listener`
+once activation resolves) and deactivates it on unmount — mirroring upstream's own
+`useKeepAwake(tag?, options?)`.
+
+## Test it
+
+No Fabric/Descriptor angle at all — keep-awake is a pure async-function + `EventEmitter` listener
+surface, never a view. Tests inject a fake native-module object in place of the real
+`requireNativeModule` resolution (`src/core/keep-awake.test.ts`,
+`src/{react,vue,angular}/**/*.test.{ts,tsx}`, `vitest`), the same pattern
+`@symbiote-native/battery` and `@symbiote-native/device` use — no `installFabric()`-driven Fabric
+assertions on the core level, only the adapter lifecycle tests mount through the fake Fabric slot
+to prove activate-on-mount/deactivate-on-unmount. Native rendering itself is verified on-device —
+see the parent [README](../../README.md).

package/build/angular/index.d.ts

@@ -0,0 +1,2 @@
+export { KeepAwakeService } from './services/keep-awake.service';
+export { ExpoKeepAwakeTag, isAvailableAsync, activateKeepAwakeAsync, deactivateKeepAwake, addListener, type KeepAwakeEvent, type KeepAwakeListener, type KeepAwakeOptions, type EventSubscription, } from '../core';

package/build/angular/index.js

@@ -0,0 +1,4 @@
+// KeepAwakeService is the Angular-only lifecycle half; the free functions and event
+// subscription plumbing all live in core, shared with React/Vue.
+export { KeepAwakeService } from './services/keep-awake.service';
+export { ExpoKeepAwakeTag, isAvailableAsync, activateKeepAwakeAsync, deactivateKeepAwake, addListener, } from '../core';

package/build/angular/services/keep-awake.service/index.d.ts

@@ -0,0 +1,5 @@
+import { type KeepAwakeOptions } from '../../../core';
+export declare class KeepAwakeService {
+    private readonly injector;
+    connect(tag?: string, options?: KeepAwakeOptions): void;
+}

package/build/angular/services/keep-awake.service/index.js

@@ -0,0 +1,83 @@
+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 { activateKeepAwakeAsync, addListener, deactivateKeepAwake, } from '../../../core';
+// Angular twin of React's `useKeepAwake` hook and Vue's `useKeepAwake` composable. See
+// LowPowerModeService (packages/battery) for the `connect()`/`effect()` pattern rationale — same
+// wiring, but keep-awake has no value to surface as a Signal since it's a pure side effect for
+// the component's lifetime. Angular has no useId equivalent either, so the default tag comes
+// from the same monotonically-incrementing module-local counter the Vue composable uses.
+//
+//   constructor() { inject(KeepAwakeService).connect(); }
+let tagCounter = 0;
+let KeepAwakeService = (() => {
+    let _classDecorators = [Injectable({ providedIn: 'root' })];
+    let _classDescriptor;
+    let _classExtraInitializers = [];
+    let _classThis;
+    var KeepAwakeService = 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);
+            KeepAwakeService = _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(tag, options) {
+            const tagOrDefault = tag ?? `keep-awake-tag-${++tagCounter}`;
+            effect(onCleanup => {
+                activateKeepAwakeAsync(tagOrDefault)
+                    .then(() => {
+                    if (options?.listener) {
+                        addListener(tagOrDefault, options.listener);
+                    }
+                })
+                    .catch(() => { });
+                onCleanup(() => {
+                    if (options?.suppressDeactivateWarnings) {
+                        deactivateKeepAwake(tagOrDefault).catch(() => { });
+                    }
+                    else {
+                        deactivateKeepAwake(tagOrDefault);
+                    }
+                });
+            }, { injector: this.injector });
+        }
+    };
+    return KeepAwakeService = _classThis;
+})();
+export { KeepAwakeService };

package/build/core/index.d.ts

@@ -0,0 +1,3 @@
+export { ExpoKeepAwakeTag, isAvailableAsync, activateKeepAwakeAsync, deactivateKeepAwake, addListener, } from './keep-awake';
+export type { KeepAwakeEvent, KeepAwakeListener, KeepAwakeOptions } from './types';
+export type { EventSubscription } from 'expo-modules-core';

package/build/core/index.js

@@ -0,0 +1 @@
+export { ExpoKeepAwakeTag, isAvailableAsync, activateKeepAwakeAsync, deactivateKeepAwake, addListener, } from './keep-awake';

package/build/core/keep-awake.d.ts

@@ -0,0 +1,17 @@
+import { type EventSubscription } from 'expo-modules-core';
+import type { KeepAwakeListener } from './types';
+export declare const ExpoKeepAwakeTag = "ExpoKeepAwakeDefaultTag";
+/** Resolves with whether the keep-awake API is available on this device. */
+export declare function isAvailableAsync(): Promise<boolean>;
+/**
+ * Activates a keep-awake lock under `tag` (the shared default tag when none is given) — the
+ * screen stays on for as long as any tag holds an active lock.
+ */
+export declare function activateKeepAwakeAsync(tag?: string): Promise<void>;
+/** Releases the keep-awake lock held under `tag` (the shared default tag when none is given). */
+export declare function deactivateKeepAwake(tag?: string): Promise<void>;
+/**
+ * Subscribes to keep-awake state changes for a tag. Overloaded to accept a bare listener for the
+ * default tag, matching upstream's own `addListener` signature.
+ */
+export declare function addListener(tagOrListener: string | KeepAwakeListener, listener?: KeepAwakeListener): EventSubscription;

package/build/core/keep-awake.js

@@ -0,0 +1,41 @@
+// Hand-ported from .vendors/expo/packages/expo-keep-awake/src/index.ts (sdk-57, confirmed
+// against origin/sdk-57 — the .vendors/expo working tree sits on `main` and differs
+// cosmetically). Unlike battery (which falls back to a sentinel when a method is missing),
+// upstream keep-awake throws from `addListener` when the native module lacks
+// `addListenerForTag`, matching local-auth/haptics's UnavailabilityError convention.
+import { UnavailabilityError } from 'expo-modules-core';
+import { expoKeepAwake } from './native-module';
+export const ExpoKeepAwakeTag = 'ExpoKeepAwakeDefaultTag';
+/** Resolves with whether the keep-awake API is available on this device. */
+export async function isAvailableAsync() {
+    if (expoKeepAwake.isAvailableAsync) {
+        return await expoKeepAwake.isAvailableAsync();
+    }
+    return true;
+}
+/**
+ * Activates a keep-awake lock under `tag` (the shared default tag when none is given) — the
+ * screen stays on for as long as any tag holds an active lock.
+ */
+export async function activateKeepAwakeAsync(tag = ExpoKeepAwakeTag) {
+    await expoKeepAwake.activate?.(tag);
+}
+/** Releases the keep-awake lock held under `tag` (the shared default tag when none is given). */
+export async function deactivateKeepAwake(tag = ExpoKeepAwakeTag) {
+    await expoKeepAwake.deactivate?.(tag);
+}
+/**
+ * Subscribes to keep-awake state changes for a tag. Overloaded to accept a bare listener for the
+ * default tag, matching upstream's own `addListener` signature.
+ */
+export function addListener(tagOrListener, listener) {
+    if (!expoKeepAwake.addListenerForTag) {
+        throw new UnavailabilityError('ExpoKeepAwake', 'addListenerForTag');
+    }
+    const tag = typeof tagOrListener === 'string' ? tagOrListener : ExpoKeepAwakeTag;
+    const resolvedListener = typeof tagOrListener === 'function' ? tagOrListener : listener;
+    if (!resolvedListener) {
+        throw new TypeError('addListener requires a listener function');
+    }
+    return expoKeepAwake.addListenerForTag(tag, resolvedListener);
+}

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

@@ -0,0 +1,9 @@
+import type { EventSubscription } from 'expo-modules-core';
+import type { KeepAwakeListener } from './types';
+export type INativeKeepAwakeModule = {
+    isAvailableAsync?(): Promise<boolean>;
+    activate?(tag: string): Promise<void>;
+    deactivate?(tag: string): Promise<void>;
+    addListenerForTag?(tag: string, listener: KeepAwakeListener): EventSubscription;
+};
+export declare const expoKeepAwake: INativeKeepAwakeModule;

package/build/core/native-module.js

@@ -0,0 +1,3 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPO_KEEP_AWAKE_MODULE_NAME = 'ExpoKeepAwake';
+export const expoKeepAwake = requireNativeModule(EXPO_KEEP_AWAKE_MODULE_NAME);

package/build/core/types.d.ts

@@ -0,0 +1,8 @@
+export type KeepAwakeEvent = {
+    state: unknown;
+};
+export type KeepAwakeListener = (event: KeepAwakeEvent) => void;
+export type KeepAwakeOptions = {
+    listener?: KeepAwakeListener;
+    suppressDeactivateWarnings?: boolean;
+};

package/build/core/types.js

@@ -0,0 +1 @@
+export {};

package/build/react/hooks/use-keep-awake/index.d.ts

@@ -0,0 +1,2 @@
+import { type KeepAwakeOptions } from '../../../core';
+export declare function useKeepAwake(tag?: string, options?: KeepAwakeOptions): void;

package/build/react/hooks/use-keep-awake/index.js

@@ -0,0 +1,35 @@
+// React lifecycle wiring over the framework-agnostic core (core/keep-awake.ts) — activates on
+// mount, deactivates on unmount, mirroring upstream's own useKeepAwake. Uses React's useId for
+// the default per-instance tag exactly like upstream, so two components calling useKeepAwake()
+// concurrently without an explicit tag don't clobber each other's activation/deactivation.
+//
+// Upstream also checks the native module's own `addListenerForTag` presence directly before
+// calling `addListener`; that private module isn't reachable from here (only core's public API
+// is), so registering the listener just goes through the same promise chain — an
+// UnavailabilityError from `addListener` is swallowed by the trailing `.catch(() => {})` exactly
+// like a rejected `activateKeepAwakeAsync`, same net effect as upstream's own guard.
+import { useEffect, useId } from 'react';
+import { activateKeepAwakeAsync, addListener, deactivateKeepAwake, } from '../../../core';
+export function useKeepAwake(tag, options) {
+    const defaultTag = useId();
+    const tagOrDefault = tag ?? defaultTag;
+    useEffect(() => {
+        let isMounted = true;
+        activateKeepAwakeAsync(tagOrDefault)
+            .then(() => {
+            if (isMounted && options?.listener) {
+                addListener(tagOrDefault, options.listener);
+            }
+        })
+            .catch(() => { });
+        return () => {
+            isMounted = false;
+            if (options?.suppressDeactivateWarnings) {
+                deactivateKeepAwake(tagOrDefault).catch(() => { });
+            }
+            else {
+                deactivateKeepAwake(tagOrDefault);
+            }
+        };
+    }, [tagOrDefault]);
+}

package/build/react/index.d.ts

@@ -0,0 +1,2 @@
+export { useKeepAwake } from './hooks/use-keep-awake';
+export { ExpoKeepAwakeTag, isAvailableAsync, activateKeepAwakeAsync, deactivateKeepAwake, addListener, type KeepAwakeEvent, type KeepAwakeListener, type KeepAwakeOptions, type EventSubscription, } from '../core';

package/build/react/index.js

@@ -0,0 +1,5 @@
+// @symbiote-native/keep-awake/react: the React entry over the framework-agnostic core. The
+// lifecycle bucket is `hooks/` (never `composables/`, that's Vue's term) — see
+// adapters/react/src/hooks for the same convention.
+export { useKeepAwake } from './hooks/use-keep-awake';
+export { ExpoKeepAwakeTag, isAvailableAsync, activateKeepAwakeAsync, deactivateKeepAwake, addListener, } from '../core';

package/build/vue/composables/use-keep-awake/index.d.ts

@@ -0,0 +1,2 @@
+import { type KeepAwakeOptions } from '../../../core';
+export declare function useKeepAwake(tag?: string, options?: KeepAwakeOptions): void;

package/build/vue/composables/use-keep-awake/index.js

@@ -0,0 +1,28 @@
+// Vue lifecycle wiring over the framework-agnostic core (core/keep-awake.ts) — activates on
+// mount, deactivates on unmount, mirroring React's useKeepAwake hook. Vue has no useId
+// equivalent, so the default tag comes from a small monotonically-incrementing module-local
+// counter instead — simplest robust way to give each composable instance its own tag when the
+// caller doesn't supply one.
+import { onMounted, onUnmounted } from '@vue/runtime-core';
+import { activateKeepAwakeAsync, addListener, deactivateKeepAwake, } from '../../../core';
+let tagCounter = 0;
+export function useKeepAwake(tag, options) {
+    const tagOrDefault = tag ?? `keep-awake-tag-${++tagCounter}`;
+    onMounted(() => {
+        activateKeepAwakeAsync(tagOrDefault)
+            .then(() => {
+            if (options?.listener) {
+                addListener(tagOrDefault, options.listener);
+            }
+        })
+            .catch(() => { });
+    });
+    onUnmounted(() => {
+        if (options?.suppressDeactivateWarnings) {
+            deactivateKeepAwake(tagOrDefault).catch(() => { });
+        }
+        else {
+            deactivateKeepAwake(tagOrDefault);
+        }
+    });
+}

package/build/vue/index.d.ts

@@ -0,0 +1,2 @@
+export { useKeepAwake } from './composables/use-keep-awake';
+export { ExpoKeepAwakeTag, isAvailableAsync, activateKeepAwakeAsync, deactivateKeepAwake, addListener, type KeepAwakeEvent, type KeepAwakeListener, type KeepAwakeOptions, type EventSubscription, } from '../core';

package/build/vue/index.js

@@ -0,0 +1,5 @@
+// @symbiote-native/keep-awake/vue: the Vue entry over the framework-agnostic core. The
+// lifecycle bucket is `composables/` (never `hooks/`, that's React's term) — see
+// adapters/vue/src/composables for the same convention.
+export { useKeepAwake } from './composables/use-keep-awake';
+export { ExpoKeepAwakeTag, isAvailableAsync, activateKeepAwakeAsync, deactivateKeepAwake, addListener, } from '../core';

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

@@ -0,0 +1,2 @@
+export { KeepAwakeService } from './services/keep-awake.service';
+export { ExpoKeepAwakeTag, isAvailableAsync, activateKeepAwakeAsync, deactivateKeepAwake, addListener, type KeepAwakeEvent, type KeepAwakeListener, type KeepAwakeOptions, type EventSubscription, } from '../core';

package/build-ngc/angular/index.js

@@ -0,0 +1,5 @@
+// KeepAwakeService is the Angular-only lifecycle half; the free functions and event
+// subscription plumbing all live in core, shared with React/Vue.
+export { KeepAwakeService } from './services/keep-awake.service';
+export { ExpoKeepAwakeTag, isAvailableAsync, activateKeepAwakeAsync, deactivateKeepAwake, addListener, } from '../core';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/angular/index.ts"],"names":[],"mappings":"AAAA,oFAAoF;AACpF,iEAAiE;AACjE,OAAO,EAAE,gBAAgB,EAAE,MAAM,+BAA+B,CAAC;AACjE,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,sBAAsB,EACtB,mBAAmB,EACnB,WAAW,GAKZ,MAAM,SAAS,CAAC"}

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

@@ -0,0 +1,8 @@
+import { type KeepAwakeOptions } from '../../../core';
+import * as i0 from "@angular/core";
+export declare class KeepAwakeService {
+    private readonly injector;
+    connect(tag?: string, options?: KeepAwakeOptions): void;
+    static ɵfac: i0.ɵɵFactoryDeclaration<KeepAwakeService, never>;
+    static ɵprov: i0.ɵɵInjectableDeclaration<KeepAwakeService>;
+}

package/build-ngc/angular/services/keep-awake.service/index.js

@@ -0,0 +1,41 @@
+import { effect, inject, Injectable, Injector } from '@angular/core';
+import { activateKeepAwakeAsync, addListener, deactivateKeepAwake, } from '../../../core';
+import * as i0 from "@angular/core";
+// Angular twin of React's `useKeepAwake` hook and Vue's `useKeepAwake` composable. See
+// LowPowerModeService (packages/battery) for the `connect()`/`effect()` pattern rationale — same
+// wiring, but keep-awake has no value to surface as a Signal since it's a pure side effect for
+// the component's lifetime. Angular has no useId equivalent either, so the default tag comes
+// from the same monotonically-incrementing module-local counter the Vue composable uses.
+//
+//   constructor() { inject(KeepAwakeService).connect(); }
+let tagCounter = 0;
+export class KeepAwakeService {
+    injector = inject(Injector);
+    connect(tag, options) {
+        const tagOrDefault = tag ?? `keep-awake-tag-${++tagCounter}`;
+        effect(onCleanup => {
+            activateKeepAwakeAsync(tagOrDefault)
+                .then(() => {
+                if (options?.listener) {
+                    addListener(tagOrDefault, options.listener);
+                }
+            })
+                .catch(() => { });
+            onCleanup(() => {
+                if (options?.suppressDeactivateWarnings) {
+                    deactivateKeepAwake(tagOrDefault).catch(() => { });
+                }
+                else {
+                    deactivateKeepAwake(tagOrDefault);
+                }
+            });
+        }, { injector: this.injector });
+    }
+    static ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: KeepAwakeService, deps: [], target: i0.ɵɵFactoryTarget.Injectable });
+    static ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: KeepAwakeService, providedIn: 'root' });
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "22.0.5", ngImport: i0, type: KeepAwakeService, decorators: [{
+            type: Injectable,
+            args: [{ providedIn: 'root' }]
+        }] });
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../../src/angular/services/keep-awake.service/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,EAAE,UAAU,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAC;AACrE,OAAO,EACL,sBAAsB,EACtB,WAAW,EACX,mBAAmB,GAEpB,MAAM,eAAe,CAAC;;AAEvB,uFAAuF;AACvF,iGAAiG;AACjG,+FAA+F;AAC/F,6FAA6F;AAC7F,yFAAyF;AACzF,EAAE;AACF,0DAA0D;AAC1D,IAAI,UAAU,GAAG,CAAC,CAAC;AAGnB,MAAM,OAAO,gBAAgB;IACV,QAAQ,GAAG,MAAM,CAAC,QAAQ,CAAC,CAAC;IAE7C,OAAO,CAAC,GAAY,EAAE,OAA0B;QAC9C,MAAM,YAAY,GAAG,GAAG,IAAI,kBAAkB,EAAE,UAAU,EAAE,CAAC;QAE7D,MAAM,CACJ,SAAS,CAAC,EAAE;YACV,sBAAsB,CAAC,YAAY,CAAC;iBACjC,IAAI,CAAC,GAAG,EAAE;gBACT,IAAI,OAAO,EAAE,QAAQ,EAAE,CAAC;oBACtB,WAAW,CAAC,YAAY,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAC;gBAC9C,CAAC;YACH,CAAC,CAAC;iBACD,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;YAEnB,SAAS,CAAC,GAAG,EAAE;gBACb,IAAI,OAAO,EAAE,0BAA0B,EAAE,CAAC;oBACxC,mBAAmB,CAAC,YAAY,CAAC,CAAC,KAAK,CAAC,GAAG,EAAE,GAAE,CAAC,CAAC,CAAC;gBACpD,CAAC;qBAAM,CAAC;oBACN,mBAAmB,CAAC,YAAY,CAAC,CAAC;gBACpC,CAAC;YACH,CAAC,CAAC,CAAC;QACL,CAAC,EACD,EAAE,QAAQ,EAAE,IAAI,CAAC,QAAQ,EAAE,CAC5B,CAAC;IACJ,CAAC;uGA1BU,gBAAgB;2GAAhB,gBAAgB,cADH,MAAM;;2FACnB,gBAAgB;kBAD5B,UAAU;mBAAC,EAAE,UAAU,EAAE,MAAM,EAAE"}

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

@@ -0,0 +1,3 @@
+export { ExpoKeepAwakeTag, isAvailableAsync, activateKeepAwakeAsync, deactivateKeepAwake, addListener, } from './keep-awake';
+export type { KeepAwakeEvent, KeepAwakeListener, KeepAwakeOptions } from './types';
+export type { EventSubscription } from 'expo-modules-core';

package/build-ngc/core/index.js

@@ -0,0 +1,2 @@
+export { ExpoKeepAwakeTag, isAvailableAsync, activateKeepAwakeAsync, deactivateKeepAwake, addListener, } from './keep-awake';
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/core/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,gBAAgB,EAChB,gBAAgB,EAChB,sBAAsB,EACtB,mBAAmB,EACnB,WAAW,GACZ,MAAM,cAAc,CAAC"}

package/build-ngc/core/keep-awake.d.ts

@@ -0,0 +1,17 @@
+import { type EventSubscription } from 'expo-modules-core';
+import type { KeepAwakeListener } from './types';
+export declare const ExpoKeepAwakeTag = "ExpoKeepAwakeDefaultTag";
+/** Resolves with whether the keep-awake API is available on this device. */
+export declare function isAvailableAsync(): Promise<boolean>;
+/**
+ * Activates a keep-awake lock under `tag` (the shared default tag when none is given) — the
+ * screen stays on for as long as any tag holds an active lock.
+ */
+export declare function activateKeepAwakeAsync(tag?: string): Promise<void>;
+/** Releases the keep-awake lock held under `tag` (the shared default tag when none is given). */
+export declare function deactivateKeepAwake(tag?: string): Promise<void>;
+/**
+ * Subscribes to keep-awake state changes for a tag. Overloaded to accept a bare listener for the
+ * default tag, matching upstream's own `addListener` signature.
+ */
+export declare function addListener(tagOrListener: string | KeepAwakeListener, listener?: KeepAwakeListener): EventSubscription;

package/build-ngc/core/keep-awake.js

@@ -0,0 +1,42 @@
+// Hand-ported from .vendors/expo/packages/expo-keep-awake/src/index.ts (sdk-57, confirmed
+// against origin/sdk-57 — the .vendors/expo working tree sits on `main` and differs
+// cosmetically). Unlike battery (which falls back to a sentinel when a method is missing),
+// upstream keep-awake throws from `addListener` when the native module lacks
+// `addListenerForTag`, matching local-auth/haptics's UnavailabilityError convention.
+import { UnavailabilityError } from 'expo-modules-core';
+import { expoKeepAwake } from './native-module';
+export const ExpoKeepAwakeTag = 'ExpoKeepAwakeDefaultTag';
+/** Resolves with whether the keep-awake API is available on this device. */
+export async function isAvailableAsync() {
+    if (expoKeepAwake.isAvailableAsync) {
+        return await expoKeepAwake.isAvailableAsync();
+    }
+    return true;
+}
+/**
+ * Activates a keep-awake lock under `tag` (the shared default tag when none is given) — the
+ * screen stays on for as long as any tag holds an active lock.
+ */
+export async function activateKeepAwakeAsync(tag = ExpoKeepAwakeTag) {
+    await expoKeepAwake.activate?.(tag);
+}
+/** Releases the keep-awake lock held under `tag` (the shared default tag when none is given). */
+export async function deactivateKeepAwake(tag = ExpoKeepAwakeTag) {
+    await expoKeepAwake.deactivate?.(tag);
+}
+/**
+ * Subscribes to keep-awake state changes for a tag. Overloaded to accept a bare listener for the
+ * default tag, matching upstream's own `addListener` signature.
+ */
+export function addListener(tagOrListener, listener) {
+    if (!expoKeepAwake.addListenerForTag) {
+        throw new UnavailabilityError('ExpoKeepAwake', 'addListenerForTag');
+    }
+    const tag = typeof tagOrListener === 'string' ? tagOrListener : ExpoKeepAwakeTag;
+    const resolvedListener = typeof tagOrListener === 'function' ? tagOrListener : listener;
+    if (!resolvedListener) {
+        throw new TypeError('addListener requires a listener function');
+    }
+    return expoKeepAwake.addListenerForTag(tag, resolvedListener);
+}
+//# sourceMappingURL=keep-awake.js.map

package/build-ngc/core/keep-awake.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"keep-awake.js","sourceRoot":"","sources":["../../src/core/keep-awake.ts"],"names":[],"mappings":"AAAA,0FAA0F;AAC1F,oFAAoF;AACpF,2FAA2F;AAC3F,6EAA6E;AAC7E,qFAAqF;AACrF,OAAO,EAAE,mBAAmB,EAA0B,MAAM,mBAAmB,CAAC;AAChF,OAAO,EAAE,aAAa,EAAE,MAAM,iBAAiB,CAAC;AAGhD,MAAM,CAAC,MAAM,gBAAgB,GAAG,yBAAyB,CAAC;AAE1D,4EAA4E;AAC5E,MAAM,CAAC,KAAK,UAAU,gBAAgB;IACpC,IAAI,aAAa,CAAC,gBAAgB,EAAE,CAAC;QACnC,OAAO,MAAM,aAAa,CAAC,gBAAgB,EAAE,CAAC;IAChD,CAAC;IACD,OAAO,IAAI,CAAC;AACd,CAAC;AAED;;;GAGG;AACH,MAAM,CAAC,KAAK,UAAU,sBAAsB,CAAC,MAAc,gBAAgB;IACzE,MAAM,aAAa,CAAC,QAAQ,EAAE,CAAC,GAAG,CAAC,CAAC;AACtC,CAAC;AAED,iGAAiG;AACjG,MAAM,CAAC,KAAK,UAAU,mBAAmB,CAAC,MAAc,gBAAgB;IACtE,MAAM,aAAa,CAAC,UAAU,EAAE,CAAC,GAAG,CAAC,CAAC;AACxC,CAAC;AAED;;;GAGG;AACH,MAAM,UAAU,WAAW,CACzB,aAAyC,EACzC,QAA4B;IAE5B,IAAI,CAAC,aAAa,CAAC,iBAAiB,EAAE,CAAC;QACrC,MAAM,IAAI,mBAAmB,CAAC,eAAe,EAAE,mBAAmB,CAAC,CAAC;IACtE,CAAC;IACD,MAAM,GAAG,GAAG,OAAO,aAAa,KAAK,QAAQ,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,gBAAgB,CAAC;IACjF,MAAM,gBAAgB,GAAG,OAAO,aAAa,KAAK,UAAU,CAAC,CAAC,CAAC,aAAa,CAAC,CAAC,CAAC,QAAQ,CAAC;IACxF,IAAI,CAAC,gBAAgB,EAAE,CAAC;QACtB,MAAM,IAAI,SAAS,CAAC,0CAA0C,CAAC,CAAC;IAClE,CAAC;IACD,OAAO,aAAa,CAAC,iBAAiB,CAAC,GAAG,EAAE,gBAAgB,CAAC,CAAC;AAChE,CAAC"}

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

@@ -0,0 +1,9 @@
+import type { EventSubscription } from 'expo-modules-core';
+import type { KeepAwakeListener } from './types';
+export type INativeKeepAwakeModule = {
+    isAvailableAsync?(): Promise<boolean>;
+    activate?(tag: string): Promise<void>;
+    deactivate?(tag: string): Promise<void>;
+    addListenerForTag?(tag: string, listener: KeepAwakeListener): EventSubscription;
+};
+export declare const expoKeepAwake: INativeKeepAwakeModule;

package/build-ngc/core/native-module.js

@@ -0,0 +1,4 @@
+import { requireNativeModule } from 'expo-modules-core';
+const EXPO_KEEP_AWAKE_MODULE_NAME = 'ExpoKeepAwake';
+export const expoKeepAwake = requireNativeModule(EXPO_KEEP_AWAKE_MODULE_NAME);
+//# sourceMappingURL=native-module.js.map